renaming finder items IV — part 3

the last two posts looked at using applescript to develop an app to make batch renaming finder items even easier than automator, or bridge, or whatever. first, we created the basic functionality, then we improved the script to make it more user friendly. this post will be the final instalment — the final revision to optimise usability.

to understand this post you’ll first need to review renaming finder items IV and renaming finder items IV — part 2.

the app has been created as a droplet — drop files on the app’s icon and they are processed by the script. pretty simple. but the app would be better still if it could be activated in a number of ways. so, we’re going to alter it so that, as well as accepting dropped files, it can accept a dropped folder of files, or just run when it is double-clicked.

it would also be better if it ran faster.

making it faster is easy. in its current form the script will rename 1000 files in a bit over a minute — not bad. but if you take every instance of this line :

tell application "Finder"

and replace it with :

tell application "System Events"

you’ll find that renaming 1000 files will take about a second. that’s even more not bad.

“System Events is an agent (or faceless background application) that supplies the terminology for using a number of features in AppleScript scripts. … Provides terminology to access disks, files, and folders without targeting the Finder. This can be more efficient than using the Finder …”
Mac Developer Library

ok, so much for speed, now for the varied functionality. the original script started with an on open command and assumed that the user would be dropping a bunch of files on the droplet.

here’s how to change that on open command so that it could accept either a bunch of files or a folder :

on open (mgDropped)
  tell application "System Events"
    if (count of mgDropped) = 1 then
      if (mgDropped as string) ends with ":" then
        set mgFiles to files of item 1 of mgDropped
      else
        display dialog "You're really using a script to rename one file?" & return & return & "OK ... whatever."
        set mgFiles to mgDropped
      end if
    else
      set mgFiles to mgDropped
    end if
  end tell
  my mgProcess(mgFiles)
end open

the files to be renamed are now defined by the variable mgFiles before being passed to the subhandler mgProcess. the reason we are now using a subhandler for the renaming is that the on open command is not the only script initiator — we’ll also be including an on run command.

the on run command is what allows the app to run by just double-clicking it. when the app is double-clicked it will ask the user to choose a folder of files to rename — again passing those files to the mgProcess subhandler. so the full start of the script now looks like this :

-- thanks to Yvan Koenig for the on run/on open clue :
-- http://macscripter.net/viewtopic.php?id=41214
on run
  set mgFolder to choose folder
  tell application "System Events"
    set mgFiles to files of mgFolder
  end tell
  my mgProcess(mgFiles)
end run

on open (mgDropped)
  tell application "System Events"
    if (count of mgDropped) = 1 then
      if (mgDropped as string) ends with ":" then
        set mgFiles to files of item 1 of mgDropped
      else
        display dialog "You're really using a script to rename one file?" & return & return & "OK ... whatever."
        set mgFiles to mgDropped
      end if
    else
      set mgFiles to mgDropped
    end if
  end tell
  my mgProcess(mgFiles)
end open
---------------------------------------------

so, to reiterate, having both the on run and on open commands allows this script to behave both as a standard app and as a droplet.

there are a bunch of other minor revisions that need to be made to the original script to accommodate this new functionality — not least the encapsulating of the basic script within a subhandler. the new completed script would look like this :
screen grab of finished EasyRenaming script

but you can get the complete EasyRenaming app here.

have fun improving this script for even greater functionality.


• related post : renaming finder items : renaming using automator or applescript.
• related post : renaming finder items II : renaming by list.
• related post : renaming finder items III : renaming by creation date.

macgrunt icon

Advertisements

renaming finder items IV — part 2

today we’re going to look at revising the script from the last post to make it more user friendly and robust. here was what we finished with last time :
screen grab of finished script

you may need to review how that script functions before proceeding : renaming finder items IV

refining a script for optimal usability is largely a matter of asking a bunch of “what if …?” questions. what if the user does this? what if the user does that? what if the user is a thicky? etc.

we’re going to do some simple refinements :

  • what if the user enters nothing in the first dialog? — we’ll give them the option to append something to the start of the filename.
  • what if the user enters nothing in the second dialog? — we’ll give them the option to simply delete the ‘change from’ text from the filename.
  • what if the user doesn’t fully understand what the script is going to do? — we’ll give them a confirmation message before proceeding.
  • how will we know how successful the script was? — we’ll include some extra reporting at the end of the process.

first we’ll add three variables right after the first line of the script :

set mgAppend to "NUP"
set mgChanged to {}
set mgUnChanged to {}

the first is a simple switch we’ll use for an if/then statement when it comes time to actually change the filenames. the other two are empty lists that will get populated as the script processes the files. these will be the basis for the end reporting.

the next part goes straight after presenting the change from dialog. it creates another window to check what to do if the user enters nothing in the change from dialog. this is where the mgAppend variable gets switched if required :

set mgChangeFrom to text returned of mgChangeFromDialog
if mgChangeFrom is "" then
  set mgJustChecking to display dialog "So, do you want to append the new text to the front of the filename?" buttons {"No — Cancel", "Yes — Append"} default button 2
  if button returned of mgJustChecking is "No — Cancel" then
    error number -128
  else
    set mgAppend to "YEP"
  end if
end if

screen grab of append check dialog window

does that all make sense so far?

now after collecting the change from and change to data from the user and running the considering case check, we’ll have three possible scenarios (apart from the script having been cancelled) :

  1. we have nothing for change from and a text string for change to (append)
  2. we have a text string for both change from and change to (replace)
  3. we have a text string for change from but nothing for change to (delete)

we can use those possible scenarios to build one of three possible confirmation dialogs like this :

if mgChangeTO is not "" then
  if mgAppend is "YEP" then
    set mgConfirmationText to "JUST CONFIRMING." & return & return & "Filenames will be changed so that :" & return & "      '" & mgChangeTO & "'." & return & "is appended to the front of each filename." & return & return & "IS THAT CORRECT?"
  else
    set mgConfirmationText to "JUST CONFIRMING." & return & return & "Filenames will be changed so that :" & return & "      '" & mgChangeFrom & "'" & return & "becomes" & return & "      '" & mgChangeTO & "'." & return & return & "IS THAT CORRECT?"
  end if
else
  set mgConfirmationText to "JUST CONFIRMING." & return & return & "Filenames will be changed so that :" & return & "      '" & mgChangeFrom & "'" & return & "is deleted." & return & return & "IS THAT CORRECT?" & return & return & return & "{WARNING : this change cannot be undone}"
end if

set mgConfirmation to display alert mgConfirmationText buttons {"HELL NO! STOP", "YES! Go do that thing"} default button "HELL NO! STOP" as critical
if button returned of mgConfirmation is "HELL NO! STOP" then
  error number -128
end if

screen grab of three confirmation dialog windows

the portion of the script that does the actual name changing is a bit more complicated now. it needs to allow for appending (as required) and for populating those two lists we need for reporting purposes :

tell application "Finder"
  repeat with mgitem in mgSelection
    set mgOriginalName to name of mgitem
    if mgAppend is "YEP" then
      set mgNewName to (mgChangeTO & mgOriginalName) as string
      set name of mgitem to mgNewName
      set end of mgChanged to mgOriginalName
    else
      set text item delimiters of AppleScript to mgChangeFrom
      set mgNameItems to text items of mgOriginalName
      set text item delimiters of AppleScript to ""
      set mgItemCount to count mgNameItems
      if mgItemCount is not 1 then
        set text item delimiters of AppleScript to mgChangeTO
        set mgNewName to mgNameItems as string
        set text item delimiters of AppleScript to "."
        set mgNameCheck to text item 1 of mgNewName
        set text item delimiters of AppleScript to ""
        if mgNameCheck is "" then
          display dialog "Sorry, You cannot have a file with no name at all" buttons "dammit" default button 1
          error number -128
        end if
        set name of mgitem to mgNewName
        set end of mgChanged to mgOriginalName
      else
        set end of mgUnChanged to mgOriginalName
      end if
    end if
  end repeat
end tell

and, finally, we have the reporting process. the original script simply popped up a window saying “All Done”. this version will give the user some helpful feedback :

set mgCountSelection to count mgSelection
set mgCountChanged to count mgChanged
set mgCountUnChanged to count mgUnChanged

if mgUnChanged is not {} then
  if mgCountUnChanged is less than 12 then
    set mgUnChangedList to "They are: " & return & "    "
    repeat with mgUnChangedItem in items of mgUnChanged
      set mgUnChangedList to mgUnChangedList & mgUnChangedItem & return & "    "
    end repeat
  else
    set mgUnChangedList to "Here are some of them: " & return & "    "
    repeat with x from 1 to 10
      set mgUnChangedItem to item x of mgUnChanged
      set mgUnChangedList to mgUnChangedList & mgUnChangedItem & return & "    "
    end repeat
  end if
end if

if mgCountSelection = mgCountChanged then
  set mgMessage to "All " & mgCountSelection & " files were successfully renamed."
else if mgCountSelection = mgCountUnChanged then
  set mgMessage to "Sorry, none of the " & mgCountSelection & " files were successfully renamed." & return & return & "You probably stuffed something up."
else
  set mgMessage to (mgCountChanged & " filenames were successfully renamed." & return & return & (count mgUnChanged) & " filenames were NOT changed because " & return & "they do not contain '" & mgChangeFrom & "'." & return & return & mgUnChangedList) as string
end if

display dialog mgMessage

the dialog will list the names of the unchanged files. if there are too many it will just list the first 10 :
screen grab of the final reporting dialog window

the finished script would look something like this.
screen grab of the finished script

there’s a bunch of different ways to improve this script. the next post will look at changing it so that it can be activated in a number of ways (rather than only by dropping files) and how to make the finished app run MUCH faster.

til then, keep grunting.


• related post : renaming finder items : renaming using automator or applescript.
• related post : renaming finder items II : renaming by list.
• related post : renaming finder items III : renaming by creation date.

macgrunt icon

renaming finder items IV

when we first started looking at batch renaming files, we saw how you could use automator to replace part of a filename with new text (see renaming finder items). here’s an applescript version of that functionality which makes batch renaming files in the finder even easier than automator.

this script works on batches of filenames that have something in common (eg. ‘12345 ThisFile_01’, ‘12345 ThisFile_02’, etc.) allowing the user to replace or add to that common element (eg. ‘ABCD_ThisFile_01’, ‘ABCD_ThisFile_02’, etc. … or … ‘12345 ThisFinishedFile_01’, ‘12345 ThisFinishedFile_02’, etc.)

the first part of the script references the selected finder items (the files to be changed) and the name of the first of these files. we use text item delimiters to strip the extension from that name :

tell application "Finder"
  set mgSelection to the selection
  set mgFirstName to name of item 1 of mgSelection
  set text item delimiters of AppleScript to "."
  set mgFirstName to text item 1 of mgFirstName
  set text item delimiters of AppleScript to ""
end tell

the next bit presents the user with two dialog windows. the first captures the change from text — with the filename from above as the initial default answer. the second captures the change to text — with the change from text as the initial default answer. including default answers in the dialog windows is a handy prompt for the user :

set mgChangeFromDialog to display dialog "What part of the filename do you want changed?" default answer mgFirstName with title "THIS SCRIPT CHANGES FILENAMES"
set mgChangeFrom to text returned of mgChangeFromDialog
delay 1
set mgChangeToDialog to display dialog "What is your new replacement text?" default answer mgChangeFrom with title "THIS SCRIPT CHANGES FILENAMES"
set mgChangeTO to text returned of mgChangeToDialog

here’s an example to make things clearer (hopefully). the first dialog is the change from window showing the first filename as it is presented to the user (left). on the right is that same window after the user specifies the part of the filename to change, before hitting ok :
screen grab of the change from dialog window

then the next dialog window — change to — pops up with that same user-defined text as the prompt (left). and the user specifies what that text should be changed to before hitting ok again (right) :
screen grab of the change to dialog window

you’ll notice in that script snippet above a one second delay between the presentation of the windows. this is purely a psychological gap to help the user realise that a new window has been presented. try it without the delay if you prefer.

next, just for shits and giggles, here’s a surly little message just in case the change from text is the same as the change to text. of course, this is entirely unnecessary — but good for a laugh :

considering case
  if mgChangeFrom = mgChangeTO then
    display dialog "OK — so you don't want any change at all." & return & return & "Thanks for wasting my time tosser." buttons {"get stuffed"} default button 1 giving up after 2
    error number -128
  end if
end considering

screen grab of surly message

that snippet demonstrates the handy ‘considering case’ control statement. this means the message would only get triggered if you tried to change “ThisFile” to “ThisFile” but not for “THISFILE” or “thisFILE” or “Thisfile” etc.

the rest of the script looks like this :

tell application "Finder"
  repeat with mgitem in mgSelection
    set mgOriginalName to name of mgitem
    set text item delimiters of AppleScript to mgChangeFrom
    set mgNameItems to text items of mgOriginalName
    set text item delimiters of AppleScript to ""
    set mgItemCount to count mgNameItems
    if mgItemCount is not 1 then
      set text item delimiters of AppleScript to mgChangeTO
      set mgNewName to mgNameItems as string
      set text item delimiters of AppleScript to ""
      set name of mgitem to mgNewName
    end if
  end repeat
end tell
set mgMessage to "All Done."
display dialog mgMessage

let’s use the examples from the dialog windows above to explain this part of the script. the files we are changing are pdfs. mgChangeFrom is ‘ThisFile’ and mgChangeTo is ‘ThisFinishedFile’. On the first pass through the loop, mgOriginalName will be the name of the first item in the Finder selection — ‘12345 ThisFile_01.pdf’. We set applescript’s text item delimiters (the characters which separate sections of text) to mgChangeFrom (‘ThisFile’) and then get the text items of mgOriginalName. this will give us the variable mgNameItems as a list — {“12345 “, “_01.pdf”}.

next we do a count of mgNameItems. if the list has only one item, it means mgOriginalName DOES NOT contain mgChangeFrom (eg. the filename ‘54321 ThatFile_31.pdf’ would return the list {“54321 ThatFile_31.pdf”}) and that file will be skipped over because the rest of the functionality is held within that if statement.

incidentally, if mgChangeFrom in our working example was ‘12345’ instead of ‘ThisFile’, the list returned would be {“”, ” ThisFile_01.pdf”} — that is, two list items — so it would pass the requirements of the if statement.

so, if the filename passes that if requirement we then change the text item delimiters to mgChangeTo (‘ThisFinishedFile’) and run the list items back together as a string — that is, {“12345 “, “_01.pdf”} becomes “12345 ThisFinishedFile_01.pdf”.

and finally there’s the line which actually does the name change. then the process is repeated for all the items in mgSelection. and we end with a message which alerts the user to the fact that the process is complete.

to turn this into a functioning app you’d add an on open handler and delete (or comment out) the line “set mgSelection to the selection”. the finished script would look like this :
screen grab of finished script

then you’d save it as an application, drag it to your sidebar, and drag-drop the files you want to rename onto it (left). and quicker than you can say “jiggle my janglers” the work’s done (right). you can see here how files that do not contain the change from text are simply skipped over :
screen grab of files being dropped onto app and finished result

so, this is the basic functioning script. but the next post will look at how to make it just a little more user friendly and robust. we need to add some error handling for different scenarios and maybe some other user safeguards.

’til then, keep grunting.


• related post : renaming finder items : renaming using automator or applescript.
• related post : renaming finder items II : renaming by list.
• related post : renaming finder items III : renaming by creation date.
• related post : renaming finder items IV — part 2 : the next step.

macgrunt icon

image processing with applescript III

a little while ago we had a look at how to use applescript and sips to scale image files without the hassle of going through photoshop – see image processing with applescript II. open the terminal application, type in “man sips” and you’ll find there’s a whole bunch stuff you can do with images without ever opening photoshop — pretty cool :
screen grab of the sips manual in terminal

… but you can play around with all that another time. today we’re focussing on extending the functionality of the image resize script from that post to make it a little more user friendly. rather than a have script that’s hard-wired to scale images to 500px high, we’ll create one that can accept user input, so that the pixel dimensions can be changed each time the script is run.

to do that we need to first create a dialog. unfortunately the dialog possibilities with standard applescript are pretty crap — particularly when compared to all the options available to applescript dialogs in InDesign – border panels, columns, rows, checkbox controls, dropdowns, enabling groups, event listeners, comboboxes, editboxes, radiobuttons, etc.

here is all you get with standard dialogs :
screen grab of dialog entry in standard additions dictionary

well, although that’s pretty diabolical, it’s still enough for what we need. here’s the first part of the script :

display dialog "enter the pixel ratio you want these scaled to" with title "resize images" default answer "800" buttons {"cancel", "wide", "high"} default button 1
set mgResult to result
set mgText to text returned of mgResult
set mgButton to button returned of mgResult

that’ll give us a dialog something like this :
screen grab of resize images script dialog

… which gives us two pieces of information — the text entered and the button clicked – both captured into variables. if you want to make the script fool-proof, you’ll need to add some error handling to ensure that the text entered is an integer. but in its current form, the script assumes that the user is not an idiot.

the next part of the script creates a subfolder in the finder to save the transformed images into (this script creates duplicates of the original images rather than overwriting the originals with the resized versions) – then creates a reference to that folder for use later in the script :

set mgFolder to (mgText & "px") as string

tell application "Finder"
  set mgItems to selection
  set mgContainer to container of item 1 of mgItems
  set mgContainer to mgContainer as alias
  if (exists folder mgFolder of folder mgContainer) is false then
    make folder at mgContainer with properties {name:mgFolder}
  end if
end tell

set mgFinalFolder to mgContainer & mgFolder & ":" as string

then comes the key to the adaptability of this script — altering the final sips command based on the user’s choices in the dialog. we capture this into a variable called mgScriptString :

if mgButton is "high" then
  set mgScriptString to "sips --resampleHeight '" & mgText & "' "
else
  if mgButton is "wide" then
    set mgScriptString to "sips --resampleWidth '" & mgText & "' "
  end if
end if

the rest of the script is pretty much as per the previous post except that we insert the mgScriptString variable into the do shell script command :

repeat with mgItem in mgItems
  set mgName to name of mgItem
  set mgFinalpath to mgFinalFolder & mgName
  set mgPath to POSIX path of (mgItem as text)
  
  --convert mgFinalpath to POSIX form
  set text item delimiters to ":"
  set mgFinalpath to text items 2 thru -1 of mgFinalpath
  set text item delimiters to "/"
  set mgFinalpath to mgFinalpath as string
  set text item delimiters to ""
  
  set mgFinalpath to quoted form of mgFinalpath
  
  try
    do shell script mgScriptString & quoted form of POSIX path of mgPath & " --out " & mgFinalpath
    do shell script "sips -m '/System/Library/ColorSync/Profiles/sRGB Profile.icc' -i " & mgFinalpath
  end try
end repeat

wrap all that in an open handler (and delete the line “set mgItems to selection”) and you’ll have a script that looks like this :
screen grab of finished script

save that as an application and whack it in your sidebar. drag and drop as many images as you like onto the app — they’ll all be scaled quicker than you could do it through photoshop. don’t worry about accidentally dropping non-image files — these just get skipped.

you can also go here to get the complete image processing script.

have a good one

macgrunt icon

aussie, aussie, aussie

someone once said — something along the lines of — “if you ever want to invade australia, do it in january, because there’s no-one doing a goddamn thing.” — which goes some way to explaining why there have been no posts this month.

so we’re going to finish this slack month with a slack post — but one which demonstrates a handy little applescript trick — the say command. and we’re going to make it a bit aussie-themed on this important anniversary because, well, why the hell not?

Australia Day Logo

to date, the scripts on this site give feedback to users through dialogs — little windows that pop up with appropriate messages. but there’s no reason why you can’t use apple’s text-to-speech technology to give verbal feedback to users when tasks are complete, or whatever.

… and it really is as simple as this :

say "something"

that will give you something in whatever the default voice is set to. there are a bunch of different voices to choose from in the speech panel of your system preferences :
screen grab of speech preferences

specifying a particular voice for your feedback is also simple :

say "aussie, aussie, aussie" using "Alex"
say "oy, oy, oy" using "Alex"

or you might prefer to use a random voice :

set mgVoices to {"Kathy", "Vicki", "Victoria", "Alex", "Bruce", "Fred"}
set mgTheVoice to some item of mgVoices
say "aussie, aussie, aussie" using mgTheVoice
say "oy, oy, oy" using mgTheVoice

and now you can also download additional voices to play around with — just click on the customise option in the system voice dropdown :
screen grab of voice download options

you can find samples of some of the voices over at NextUp

but …
you have to be a little careful with your voice choice. here’s a little homage to monty python :

say "strailya, strailya, strailya, we love you" using "Bruce"

now bruce doesn’t do a bad job (alex is better) but how would it sound with an australian voice? well the results are disappointing — karen (who pronounces her name more like ‘corinne’) doesn’t know how to speak australian. i reckon she’s a ring-in. when asked to say ‘strailya’ — a very basic aussie term — she instead says ‘stray liar’ — very odd behaviour for an aussie sheila.

the closest you’ll get with poor old kazza is this :

say "strail yuh, strail yuh, strail yuh, we love you" using "Karen"

… and the same goes for that un-australian “Lee” too — flamin’ wowser.

there are a few other things you can play around with when using the say command (rate, pitch modulation, volume, etc). check out the standard additions dictionary. unfortunately, not all properties work with all voices (eg. pitch and modulation do not affect the australian voices) :

say "chuckus a tinny would you darlin?" using "Lee" speaking rate 200
delay 0.2
say "no worries love" using "Karen" speaking rate 130

have a bonza aussie day — and keep grunting

macgrunt icon