I have a mac mini set up as a HTPC. The music end of this was a bit neglected as it was originally set up to use a custom onscreen menu control to switch between several different iTunes libraries and then have basic control within them.

Now that we have iPhones in the house – I consolidated the decade + worth of iTunes libraries into one.

I wanted a way to control the speakers based on iTunes state.

So this little python script runs every 10 seconds, here is a quick outline of what it does.

If iTunes is playing, but the speakers are off – then adjust some volumes on the speakers, turn them on, then rewind the track.

If iTunes is paused for more than 2 minutes, and the speakers are on – and they were turned on by this autodetect system, then turn the speakers off.

The turning on and off is done by my original HTPC applescript which controls an irTrans USB IR transceiver through the iRed software.

Now we just fire up the remote app on the phone, and within a few seconds the speakers are on and the music is playing.

#!/usr/bin/env python
# encoding: utf-8
"""

Created by Preston Holmes on 2009-09-05.
preston@ptone.com
Copyright (c) 2009

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""

import sys
import os
from appscript import *
from subprocess import Popen, call, STDOUT, PIPE
import plistlib
import time

prefs = '/Library/Preferences/com.ptone.tuneswatcher.plist'
vol_target = '/Users/Preston/Documents/HTPC/targetvolume'

def sh(cmd):
    return Popen(cmd,shell=True,stdout=PIPE,stderr=PIPE).communicate()[0]

def itunes_running_():
    for p in psi.process.ProcessTable().items():
        try:
            if "Applications/iTunes" in p.command:
                return True
        except:
            pass
    return False

def init_prefs ():
    d = {'state':'unknown','last_state_change':time.time(),'auto_on':False}
    plistlib.writePlist (d,prefs)

def itunes_running():
    pcount = sh('ps -xa | grep -c iTunes').strip()
    return int(pcount) > 3

def getSettings():
    settings_file = '/Users/preston/Documents/HTPC/settings'
    f = open(settings_file,'r')
    flines = f.readlines()
    f.close()
    settingsDict = {}
    for aLine in flines:
        aLine = aLine.rstrip('\n')
        #print aLine
        if aLine != '':
            apair = aLine.split(' ')
            settingsDict[apair[0]] = apair[1]
    return settingsDict

def read_prefs ():
    if not os.path.exists (prefs):
        init_prefs()
    d = plistlib.readPlist (prefs)
    htpc_settings = getSettings()
    d.update(htpc_settings)
    return d

def save_prefs(d):
    plistlib.writePlist (d,prefs)

def main():
    d = read_prefs()
    # print d
    is_running = itunes_running()
    if is_running:
        tunes = app("iTunes")
        # print "tunes.running"
        playing = (tunes.player_state() == k.playing)
        # print tunes.player_state() 
        # print playing
        if playing:  
            # print "tunes.playing"
            if d['speakers'] == 'off':
                # turn on speakers
                tunes.pause()
                sh ("""osascript -e 'tell application "HTPC" to power_speakers()'""")
                if int(d['volume']) < 40:
                    open(vol_target,'w').write("50")
                    sh ("""osascript -e 'tell application "HTPC" to setVolume()'""")
                tunes.sound_volume.set(60)
                tunes.player_position.set(0)
                tunes.play()
                d['auto_on'] = True
                save_prefs(d)
                # start streamer here?
            if d['state'] != 'playing':
                d['state'] = 'playing'
                d['last_state_change'] = time.time()
                save_prefs(d)


        else: # iTunes not playing
            if d['state'] == 'playing':
                d['state'] = 'stopped'
                d['last_state_change'] = time.time()
                save_prefs(d)
            # check if last change was 5 minutes ago and turn off speakers
            if d['auto_on'] and ((time.time() - d['last_state_change']) > 10):
                if d['speakers'] == 'on':
                    # turn speakers off only if turned on automatically
                    sh ("""osascript -e 'tell application "HTPC" to power_speakers()'""")
                    sh ("""osascript -e 'tell application "HTPC" to calibrateVolume()'""")
                d['auto_on'] = False
                save_prefs(d)
        # print (tunes.player_state() == k.stopped)


if __name__ == '__main__':
    main()

The script monitors http://images.apple.com/downloads/macosx/apple/recent.rss and if it has been updated since last check (stores the last check in a plist file) it will check the feed links for any dmg it can find and download it to /downloaded_dmgs/ (which is easy enough to change in the script source)

The script source is below the fold – or download here

#!/usr/bin/env python
# encoding: utf-8
"""
This script attempts to download any dmg files it can find in Apple's RSS feed of updates

requires BeautifulSoup and feedparser modules

Created by Preston Holmes on 2009-07-15.
preston@ptone.com
Copyright (c) 2009

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""

import sys
import os
import feedparser
import urllib, urllib2
from BeautifulSoup import BeautifulSoup
import plistlib
import re
import pdb
import time

feed_url = 'http://images.apple.com/downloads/macosx/apple/recent.rss'
dmg_location = '/downloaded_dmgs/'
prefs_file = '/Library/Preferences/com.ptone.updatefetcher.plist'

last_done = 0
ticker = 0
current_download = {}
last_msg = ''
debug = False

def download_status(block_ct,block_sz,total):
    """The hook will be passed three arguments; a count of blocks transferred so far, a block size in bytes, and the total size of the file."""
    global last_done, current_download,ticker,last_msg
    now = time.time()
    done = ((block_ct * block_sz)/float(total)) * 100
    if done > last_done + 5 and now-ticker > 1:
        msg = "downloading %s, %smb %s %% done" % (current_download['entry'],total/(1024*1024),int(done)) 
        sys.stderr.write(''.ljust(len(last_msg),'\b'))
        sys.stderr.write(msg)
        last_msg = msg
        sys.stderr.flush()
        last_done = done
        ticker = now

def get_dmg_from_iframepage(url):
    """Sleuths out the dmg url from pages that have an iFrame download form like iTunes and Safari"""
    # pdb.set_trace()
    if not url.endswith('/'):
        return False
    soup = BeautifulSoup(urllib2.urlopen(url).read())
    iframe_url = soup.find('iframe',src=re.compile('.*swdlp.apple.com.*'))
    if not iframe_url: 
        return False
    else:
        iframe_url = iframe_url['src']
    # user agent is needed to get the mac version of safari
    user_agent = 'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_7; en-us) AppleWebKit/531.2+ (KHTML, like Gecko) Version/4.0.1 Safari/530.18'
    headers = { 'User-Agent' : user_agent }
    req = urllib2.Request(iframe_url, headers=headers)
    page_data = urllib2.urlopen(req).read()
    soup = BeautifulSoup(page_data)
    dmgs = soup.findAll('input',attrs = {'type':'hidden','name':'downloadURL','value':re.compile('.*dmg$')})
    if len(dmgs) > 0:
        return [i['value'] for i in dmgs]
    else:
        return False

def clear_status():
    global current_download,last_done,last_msg
    if last_done > 0:
        sys.stderr.write(''.ljust(len(last_msg),'\b'))
        sys.stderr.write(''.ljust(len(last_msg),' '))
        sys.stderr.write('\r')
        sys.stdout.flush()
    last_done = 0
    last_msg = ''
    
def get_dmg(dmg_url):
    global current_download,last_done,last_msg
    # do fancy clearing of % done
    clear_status()
    fname = dmg_url.split('/')[-1]
    fpath = os.path.join(dmg_location,fname)
    if os.path.exists(fpath): 
        print "%s already downloaded" % fname
    else:
        # save the dmg
        current_download['fname'] = fname
        urllib.urlretrieve (dmg_url,fpath,download_status)
        clear_status()
        print 'downloaded: %s' % current_download['entry']

def main():
    print "============ Script Run %s ============" % time.asctime()
    prefs = {}
    global current_download, last_done, last_msg

    print "Parsing Feed"
    feed = feedparser.parse(feed_url)
    feed_time = time.mktime (feed.feed.updated_parsed)
    if os.path.exists(prefs_file):
        prefs = plistlib.readPlist(prefs_file)
    else:
        prefs = {'last_check':feed_time - 1000}
    
    if debug: prefs = {'last_check':feed_time - 1000}
    
    now = time.mktime(time.gmtime())
    # print feed_time
    # print now
    if feed_time <= prefs['last_check']:
        print "Feed not updated since last check"
        prefs['last_check'] = now
        plistlib.writePlist(prefs, prefs_file)
        sys.exit()
    else:
        print "feed updated %s" % feed.feed.updated
    if not os.path.exists(dmg_location): os.makedirs(dmg_location)
    # loop over the entries
    for entry in feed.entries:
        current_download = {'entry':entry.title}
        dmg_found = False
        url = entry.link
        # load link with urllib2 into beautiful soup
        soup = BeautifulSoup(urllib2.urlopen(url).read())
        # find sidecar link
        downloads = soup.findAll('a',href=re.compile('http://wsidecar.*'))
        if downloads:
            download_url = downloads[0]['href']
            # determine if link is dmg                
            if download_url.endswith('.dmg'):
                dmg_found = True
                # make it a list for compatibility with pages that return multiple dmgs
                dmg_urls = [download_url]
            else:
                dmg_found = dmg_urls = get_dmg_from_iframepage(download_url)            
            if dmg_found:
                for a_dmg in dmg_urls:
                    get_dmg(a_dmg)
            else:
                print "no dmg found in %s" % entry.title
                
    prefs['last_check'] = now
    plistlib.writePlist(prefs, prefs_file)
    
if __name__ == '__main__':
    main()

The Problem

There is often the need in a deployment scenario to repackage an installer into some other format. This might be a radmind transcript, a simple payload only installer package or perhaps just a manifest of what exactly changed on the system.

Apple installer style packages contain simple payloads, but often contain pre or postflight scripts which can make additional and important changes to the filesystem.

There are a couple methods that have been used to try to deduce what exactly was installed:

The snapshot method:

This involves taking a snapshot of the filesystem before and after the install and diffing for changes – this is a common method of building radmind transcripts. One disadvantage of this is that it requires two complete traverses of the entire filesystem to determine changes. Not so horrible, but if you have 10 minor updates, it can add up.

The packagemaker watch:

From the packagemaker man page:

If the –watch flag is specified, packagemaker will monitor filesystem changes until it receives the SIGUSR1 signal. It will then construct a package of all files that were created/modified while it was watching.

The problem with these first two methods is that the filesystem is a noisy place, with all sort of changes being made by the various processes running. These are captured with the above methods and then need to be sorted through by hand. There can arise a lot of confusion over whether a given change was made by the installer or by some other process as all changes are captured without any note of the source of the change.

Install on non-boot volume:

Installing on a non-boot volume with the snapshot method resolves the noise issue, as generally most of the FS noise is happening on the boot volume. The problem with this method is that a number of installers either expect or require, sometimes quietly and implicitly that they be run on the boot volume.

Shooting for the best of both worlds

Download watchedinstall

watchedinstall is a tool composed of a FSEvents logging tool and a Python script that tries to determine exactly what gets installed by an installer.

The tool takes an apple installer package, or the process id (pid) of a 3rd party installer and then logs two sets of information while the installer runs:

• All spawned processes and their parent
• All changes to the filesystem

When the installation is done, watched install builds a list of all the processes involved in the installation. Even for something simple like the sound effects installer from iLife involves nearly a dozen descendent processes of the initial installer process.

This list of installer related pids is used to filter the list of FS changes to only those made by the installation process.

The filtered list of changes is then output in a number of formats, currently the choices are:

• A radmind transcript
• A simple payload installer package
• A text file manifest of the changes

Installation

1. Copy the fsewatcher tool somewhere on your path, for example /usr/local/bin and make sure its executable (chmod +x)

2. The watchedinstall.py python script can be run from anywhere.

Usage

You must run watchedinstall.py as root – it will fire up the companion fsewatcher tool as long as it can be found in your path.

You can make the watchedinstall.py file executable, or just run it through the Python interpreter directly.

The script uses the following options:

• -h, –help for a more concise form of this help
• -v, –verbose display all verbose installer output
• -e, –english-only filter out non english project files
• -o PATH, –output=PATH

file to save results in, if not specified use standard out. If not specified verbosity will be disabled so that standard output is a clean representation of the output. Standard out results only make sense for radmind and standard formats. If the argument is a directory, the script will try to intelligently name the output file based on the installer source. So iLifeUpdate02.pkg becomes a transcript iLifeUpdate02.T for radmind output, or iLifeUpdate02-repack.pkg for package format.

• -f [radmind | standard | package], –format=[radmind | standard | package] Format for output file, default: radmind.

  • Radmind format will create a radmind transcript.

    Radmind format requires radmind be installed.

  • Standard output creates a text file manifest of changes.

  • Package format will create a simple payload package (no scripts) of the changes made.

    The way packagemaker works is it will use the permissions of the boot volume for those in the package.

    Also the ‘package’ format requires the install target be the boot volume.

    The package format option requires that developer tools be installed.

• -i PID, –pid=PID

Manually specify the PID of the parent installer process. If you are using a non-Apple installer style installer (ie installerVISE) you can fire up the installer, determine its pid from a tool like PS or Activity Monitor and pass that pid to watchedinstall. Once watched install is running, you can then return to the installer and start the installation. When the installer quits, watchedinstall will finish its work.

Installer Options: These options apply if you are choosing to invoke Apple’s installer with a package

• -p PATH, –package=PATH package to install, can be an mpkg
• -t PATH, –target=PATH target of package install, defaults to /

Radmind Options: These options only apply if the radmind format is used

• -K PATH path to command file, default is standard command.K
• -I use case insensitive sorting
• -C [ . | / ], –comparison-path=[ . | / ] comparison path to use, default is relative
• -c [ only sha1 supported ] checksum if any, only sha1 supported for -P option
• -P enable experimental pure python fsdiff output (a bit faster – but not recommended)

Note that any radmind excludes are parsed and respected.

Usage Examples

sudo python path/to/watchedinstall.py -ve -p path/to/AppleIntermediateCodec.pkg -o /transcripts/ -I

will create /transcripts/AppleIntermediateCodec.T without english support files

sudo python path/to/watchedinstall.py -K /var/radmind/client/clientUpdate.K -I -p path/to/AppleIntermediateCodec.pkg > /AIC.T

will create /AIC.T

sudo python path/to/watchedinstall.py --format standard -p path/to/AppleIntermediateCodec.pkg > /AIC.txt

creates a textfile manifest of filesystem changes

sudo python path/to/watchedinstall.py -e -o /Packages/ --format package -p path/to/AppleIntermediateCodec.pkg

repacks the installer into payload only package without non-english files at /Packages/AppleIntermediateCodec-repack.pkg

I work at a school where I’m involved in putting together our yearbook. For several years now we have done a collage of self portraits.

These can be a chore to layout in Illustrator. You want to randomize the grades, scale everything to be in nice rows and line everything up.

Here is what I started with:

Each grade is a different layer (and highlight color)

Its hard to know what size to standardize on to flow these out best onto the cover layout (its a front and back deal) Also I don’t want all of one grade next to another, so they need some shuffling.

So I whipped up this python script to do the grunt work for me.

quick digression on scripting language Note I could have done this in Applescript – and for most of you that would be easier to use. I think that for quick scripts where the bulk of the script is generating apple events – Applescript is generally easier. But as soon as you involve much general programming, Applescript is sorely lacking. It has an awkward and verbose syntax, and has a very limited standard library – so you often have to write all your own utilities. appscript is a Python module that provides access to Apples OSA system and allows you to do anything you can do in Applescript. The syntax takes some getting used to, but if you need to do other things in your script – its a win. For example the “Shuffle” bit in the code below was a single line of python, but would have required a PITA sub-routine in Applescript.

#!/usr/bin/env python
# encoding: utf-8
"""
Created by Preston Holmes on 2009-06-04.
"""

import sys
import os
import appscript
import random
import time
def main():
    il = appscript.app("Adobe Illustrator")
    page_items = il.current_document.page_items()
    random_index = range(len(page_items))
    random.shuffle(random_index)
    left_edge = 15
    curr_x = left_edge
    curr_y = 775
    x_max = 600
    row_height = 80
    print len(random_index)
    for i in random_index:
        item = page_items[i]
        if item.locked() or item.layer.locked():
            continue
        h = item.height()
        w = item.width()
        if h == 0 or w ==0:
            continue
        s = int ((row_height/h) * 100)
        # s2 = row_height/h
        if (curr_x + w) > x_max:
            curr_x = left_edge
            curr_y = curr_y - row_height
        sm = il.get_scale_matrix(horizontal_scale=s,vertical_scale=s)
        # Having some real problems with scale transforms screwing up stroke width - but I'm just working with placed items
        il.transform(item,using=sm,line_scale=100,transforming_stroke_patterns=False)
        # item.stroked_width.set(1)
        # alternate scale approach (also seems to affect stroke width...)
        # item.width.set(w*s2)
        # item.height.set(h*s2)
        left,top,right,bottom = item.geometric_bounds()
        dx = curr_x - left
        dy = curr_y - top
        m = il.get_translation_matrix(delta_x=dx,delta_y=dy)
        # can't use concatenated transform as scale will change the amount to move...
        # full_m = il.concatenate_scale_matrix(m,horizontal_scale=s,vertical_scale=s)
        il.transform(item,using=m)
        curr_x = curr_x + (right - left)

    

if __name__ == '__main__':
    main()

So what does this get me?

I made this to generate one page width – and its easy to split up across pages:

And as you can see, it also shuffled the source layers:

Now if I want to change how it flows – or add or subtract images I can just change the single row_height parameter of the script and get variations like this:

If you realize an image needs 90 degree rotation, it no longer requires having to entirely re-layout the whole project

Of course there is still some massaging needed by hand – but it is a fraction of the effort.

I try to keep up with them, use them where possible, but don’t put EVERYTHING I do in version control. Since I am on a Mac running Leopard, I do have, and use Time Machine and so wanted to see if it would be pretty easy to use that to do some quick diffs between some source files.

The result is a quick and dirty python script. In the unlikely event that I ever have time, this would be a cool pyObjC project, a file browser panel, date versions picker, and a webkit view (with some better css).

The source to the script is below the fold – it will look for the first attached volume that has time machine backups for the current machine. It will not work with network based time machine backups that are on disk images. This script will run on a stock Leopard install without any extra python modules needed.

#!/usr/bin/env python
# encoding: utf-8
"""
Created by Preston Holmes on 2009-02-23.
Copyright (c) 2009 __MyCompanyName__. All rights reserved.
"""

import sys
import os
import getopt
import difflib
import time
import pdb
from subprocess import Popen, PIPE

# if you set time_machine_path, it should be to the full path of this machines backup drive:
# ie '/Volumes/TM_Drive/Backups.backupsdb/Joes-Mac/'
# if not set explicitly - the script will use the first TM drive it finds, 
# and the first host folder it finds - which should work for most cases
# Will Not work with network or disk image based time machine backups

time_machine_path = None

cmd = 'tell application "Finder" to name of (path to startup disk)'
boot_volume = Popen('osascript -e \'%s\'' % cmd,shell=True,stdout=PIPE,stderr=PIPE).communicate()[0][0:-1]



help_message = '''
Call this script with the path to one or more text based files as arguments
'''
header = '''

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
          "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html>

<head>
    <meta http-equiv="Content-Type"
          content="text/html; charset=ISO-8859-1" />
    <title></title>
    <style type="text/css">
        table.diff {font-family:Courier; border:medium;}
        .diff_header {background-color:#e0e0e0}
        td.diff_header {text-align:right}
        .diff_next {background-color:#c0c0c0}
        .diff_add {background-color:#aaffaa}
        .diff_chg {background-color:#ffff77}
        .diff_sub {background-color:#ffaaaa}
    </style>
</head>

<body>
'''
footer = '''
    <table class="diff" summary="Legends">
        <tr> <th colspan="2"> Legends </th> </tr>
        <tr> <td> <table border="" summary="Colors">
                      <tr><th> Colors </th> </tr>
                      <tr><td class="diff_add">&nbsp;Added&nbsp;</td></tr>
                      <tr><td class="diff_chg">Changed</td> </tr>
                      <tr><td class="diff_sub">Deleted</td> </tr>
                  </table></td>
             <td> <table border="" summary="Links">
                      <tr><th colspan="2"> Links </th> </tr>
                      <tr><td>(f)irst change</td> </tr>
                      <tr><td>(n)ext change</td> </tr>
                      <tr><td>(t)op</td> </tr>
                  </table></td> </tr>
    </table>
</body>

</html>
'''
class Usage(Exception):
    def __init__(self, msg):
        self.msg = msg

def find_versions(path):
    #pdb.set_trace()
    print 'looking for versions of %s' % path
    #print time.strftime("%m/%d/%Y %I:%M:%S %p",time.localtime(os.path.getmtime(fname)))
    backups = os.listdir(time_machine_path)
    backups.sort()
    pathlist = [os.path.join(time_machine_path,b,boot_volume,path[1:]) for b in backups]
    pathlist.append(path)
    versions = []
    mod_times = []
    for f in pathlist:
        if os.path.exists(f):
            mod_time = time.localtime(os.path.getmtime(f))
            if not mod_time in mod_times:
                mod_times.append(mod_time)
                versions.append({mod_time:f})
    return versions
    
def getTMLocation():
    global time_machine_path
    if time_machine_path and os.path.exists(time_machine_path):
        return True
    volumes = os.listdir('/Volumes')
    #hostname = os.uname()[1].split('.')[0]
    #cmd = 'scutil --get ComputerName'
    #machine_name = Popen('osascript -e \'%s\'' % cmd,shell=True,stdout=PIPE,stderr=PIPE).communicate()[0][0:-1]
    for v in volumes:
        if os.path.exists(os.path.join('/Volumes',v,'Backups.backupdb')):
            backupsdb = (os.path.join('/Volumes',v,'Backups.backupdb'))
            time_machine_path = os.path.join(backupsdb,os.listdir(backupsdb)[0])
            return True
            # candidate_path = os.path.join('/Volumes',v,'Backups.backupdb',machine_name)
            # if os.path.exists(candidate_path):
            #     time_machine_path = candidate_path
            #     return True
    return False
    
def main(argv=None):
    
    if not getTMLocation():
        print 'No Time Macine Backup Found'
        sys.exit()
    print 'time machine path: ' + time_machine_path
    if argv is None:
        argv = sys.argv
    try:
        try:
            opts, args = getopt.getopt(argv[1:], "ho:v", ["help", "output="])
        except getopt.error, msg:
            raise Usage(msg)
    
        # option processing
        for option, value in opts:
            if option == "-v":
                verbose = True
            if option in ("-h", "–help"):
                raise Usage(help_message)
            if option in ("-o", "–output"):
                output = value
        if not args:
            raise Usage(help_message)
        differ = difflib.HtmlDiff(tabsize=4)
        html = header
        for path in args:
            path = os.path.join(os.getcwd(),path)
            html += '<h1>Changes for %s</h1' % os.path.basename(path)
            versions = find_versions(path)
            if len(versions) < 2:
                html += '<h2>Less than 2 Versions found on Time Machine Backup</h2>'
            else:
                html += '<h2>%s versions found</h2>' % len(versions)
            for i in range(0,len(versions)):
                if i: #skip the first
                    d1 = time.strftime("%m/%d/%Y %I:%M:%S %p",versions[i-1].keys()[0])
                    d2 = time.strftime("%m/%d/%Y %I:%M:%S %p",versions[i].keys()[0])
                    html = html + '<h2>changes from %s to %s</h2>' % (d1,d2)
                    l1 = open(versions[i-1].values()[0]).readlines()
                    l2 = open(versions[i].values()[0]).readlines()
                    table = differ.make_table(l1,l2,context=True,numlines=3)
                    html += table
        html += footer
        o = open('/tmp/diff.html','w')
        o.write(html)
        o.close()
        import webbrowser
        webbrowser.open('/tmp/diff.html')
    except Usage, err:
        print >> sys.stderr, sys.argv[0].split("/")[-1] + ": " + str(err.msg)
        print >> sys.stderr, "\t for help use –help"
        return 2


if __name__ == "__main__":
    sys.exit(main())

http://www.domain.net/cgi-bin/sendmemail.py?to=number@txt.att.net&subject=printing_done

I use this via curl in other scripts as a sort of notification system.

#! /usr/bin/env python
import cgi,cgitb
cgitb.enable()
# Required header that tells the browser how to render the text.
print "Content-Type: text/plain\n\n"


# Print a simple message to the display window.
from email.MIMEText import MIMEText
import smtplib,sys

The_Form = cgi.FieldStorage()

body='''blank
'''

msg = MIMEText(body)

mfrom = "email@example.com"
to = TheForm['to'].value
msg['From'] = mfrom
msg['To'] = to
msg['Subject'] = TheForm['subject'].value

server = smtplib.SMTP("smtp.gmail.com",587)
server.ehlo()
server.starttls()
server.ehlo()
server.login(<smtp login>,<smtp password>)
server.sendmail(mfrom,[to],msg.as_string())
server.quit
print 'sent'