Creating a list from text

This is relatively easy using AppleScript's text item delimiters to break up a string/text object:

set theSourceText to "song1,artist1,album1
song2,artist1,album1" -- or however you extract it from your library.

set myList to {} -- start with an empty list
set oldTIDs to AppleScript's text item delimiters -- store the current TID
set my text item delimiters to "," -- set the TID to comma
repeat with eachTrack in (paragraphs of theSourceText) -- iterate through the source
copy (text items of eachTrack) to end of myList
end repeat
set AppleScript's text item delimiters to oldTIDs -- restore the TIDs
return myList

--> {{"song1", "artist1", "album1"}, {"song2", "artist1", "album1"}}

This works because when you ask for 'text items' of a string, AppleScript uses the current 'text item delimiters' to work out how to break the string into components. It's important, though, to restore the original settings when you're done, or unexpected things can happen.

Note also, that iTunes is pretty scriptable, and this data is available directly, without having to awk the library XML file:

set myList to {}
tell application "iTunes"
repeat with eachTrack in (get every track)
tell eachTrack to copy {name, artist, album} to end of myList
end repeat
end tell

I'm surprised it takes that long to extract the data from iTunes directly, but I understand your concern.

If the text manipulation code is still slower than you'd like, then consider changing the awk script to output the data in the format you require, e.g. literally have it write:

{ {"song1", "artist1", "artist2"}, {"song2", "artist1", "album1"} }

with all the brackets, quotes, commas, etc. You can then run this through AppleScript's run script command that will effectively turn it into an AppleScript list:

set awkOutput to do shell script "whatever" -- your awk script
run script awkOutput

Maybe you might also try the following script, which is very much like the one that Camelot suggested. On my computer, it took about one minute to make a list of 1127 triplets.

tell application "iTunes"
set myList to {}
set myListRef to a reference to myList
tell playlist "Music" of source "Library"
repeat with k from 1 to number of tracks
copy {name, artist, album} of file track k to the end of myListRef
end repeat
end tell
myList
end tell

The script uses the information about large lists given on page 91 of the AppleScript Language Guide.

I was so sure that my script would be much faster than the one suggested by Camelot that I didn't even test his before posting mine. But I was wrong: there isn't much difference between them (at least with around one thousand tracks). 😟

It looks like the main culprits are the repeat statement and getting multiple properties from the tracks. Since getting a single property from the tracks seems to be fairly speedy, I tried using separate lists for each property - on my machine, this wound up being 20 times faster (!!). I don't know how much it will improve the times on your G4, but you might give it a try:

<pre style="
font-family: Monaco, 'Courier New', Courier, monospace;
font-size: 10px;
font-weight: normal;
margin: 0px;
padding: 5px;
border: 1px solid #000000;
width: 720px;
color: #000000;
background-color: #FFEE80;
overflow: auto;"
title="this text can be pasted into the Script Editor">
set myList to {}
set myListRef to a reference to myList
tell application "iTunes"
set theNames to (get name of every track)
set theArtists to (get artist of every track)
set theAlbums to (get album of every track)
end tell

repeat with X from 1 to (count theNames)
set the end of myListRef to {item X of theNames, item X of theArtists, item X of theAlbums}
end repeat
</pre>

If speed is your primary goal, this seems to be the fastest pure-AppleScript solution I've come up with:

tell application "iTunes"
set trackData to (get {name, artist, album} of every track)
end tell
set outputList to {}
repeat with i from 1 to (count item 1 of trackData)
copy {item i of item 1 of trackData, item i of item 2 of trackData, item i of item 3 of trackData} to end of outputList
end repeat

This works by asking iTunes just for the data you're after (rather than getting all the track data and manually extracting the data you want). The downside is that this generates three lists, one for each of name, artist and album, hence the second block that refactors the lists into the desired format.

OMM this takes about 5 seconds to process a 1740-track library, compared to 14-15 seconds for the previous incarnations.

And to go even further, you can put the track information into a script property. Using all of the techniques posted so far, processing 4200 tracks on my machine takes about a second (actually, formatting the Script Editor's result takes longer than getting the list).

<pre style="
font-family: Monaco, 'Courier New', Courier, monospace;
font-size: 10px;
font-weight: normal;
margin: 0px;
padding: 5px;
border: 1px solid #000000;
width: 720px;
color: #000000;
background-color: #FFEE80;
overflow: auto;"
title="this text can be pasted into the Script Editor">
script GetStuff
property Stuff : {}
tell application "iTunes" to set Stuff to (get {name, artist, album} of every track)
end script
run GetStuff

set myList to {}
set myListRef to a reference to myList
repeat with X from 1 to (count item 1 of GetStuff's Stuff)
copy {item X of item 1 of GetStuff's Stuff, item X of item 2 of GetStuff's Stuff, item X of item 3 of GetStuff's Stuff} to the end of myListRef
end repeat
myList
</pre>

It looks like the main culprits are the repeat statement and getting multiple properties from the tracks

Actually, that doesn't seem to be the problem. OMM, both:

set trackData to {name, artist, album} of every track

and:

set theNames to name of every track
set theArtists to artist of every track
set theAlbums to album of every track

Take almost exactly the same amount of time (0.93 seconds vs. 0.92 seconds).

What seems to make the difference is using the reference to the list vs. manipulating the list directly. I always forget that one. OMM:

set the end of myList to {item X of theNames, item X of theArtists, item X of theAlbums}

takes 5.09 seconds, vs.:

set the end of myListRef to {item X of theNames, item X of theArtists, item X of theAlbums}

which takes 2.78 seconds. I really wish Apple would fix that one 🙂

Message was edited by: Camelot

I was referring to your original iTunes script where you were getting the properties by repeating through each track item, but yes, it would be nice to get rid of some of those performance issues. I think that is what makes AppleScript so frustrating at times - from your original example script to one that uses references and script objects, I'm getting speeds of over 250 times faster.