#!/usr/bin/env python
"""
Processing Images

"""
__author__ = """Seunghoon Kim (ski819)"""
__date__ = "$Date: 2006-04-17 (Mon, 17 Apr 2006) $"
__revision__ = "Homework 2"
#    Copyright (C) 2006 by 
#    Seunghoon Kim <seunghoon@northwestern.edu>
#
#	 Usage: ./montage.py (dirname) (number of pictures to montage)
#

import os, sys, re, string

if __name__ == '__main__':
	dirname, numpics = sys.argv[1], int(sys.argv[2])
	lspath = ["ls -R"] + [dirname] + ["> list"]
	os.system(string.join(lspath))
	list = open("list", 'r')
	ls = list.read()
	fnames = ls.split()
#	print fnames
	
	print dirname
#	os.chdir(dirname)
#	print os.system("pwd")

	montageset = []
	addpath = []
	addpath.append(dirname)
	addpath.append("/")
	print addpath

	picsatt = 0
	picindex = 0
	while picsatt < numpics:
		completepath = [fnames[picindex]]
		completepath = addpath + completepath
		temppath = string.join(completepath,'')
		completepath = ["identify"] + [temppath] + ["> id"]
		#completepath = string.join(addpath, fnames[i])
		#print completepath
		ident = 1									# for testing purpose
		ident = os.system(string.join(completepath))  # returns jpeg,png,gif
		#print "ident returns", ident
		iden = open("id", 'r')
		ide = iden.read()
		id = ide.split()
		if len(id):
			#print id
			if id[1] in ['JPEG','PNG','GIF']:
				montageset.append(temppath)
				picsatt += 1
				print "Collecting picture #", picsatt, "out of", numpics
		picindex += 1
	
	montageadd = ["montage"] + montageset + ["montage.png"]
	#print montageset
	#print montageadd
	montagecmd = string.join(montageadd)
	print "creating montage.png.......please wait"
	os.system(montagecmd)
	print "Done!!!"

Regular expression 

• dupwords.py - finds duplicate words in the input string

#!/usr/bin/env python
"""
Regular Expression I

"""
__author__ = """Seunghoon Kim (ski819)"""
__date__ = "$Date: 2006-04-17 (Mon, 17 Apr 2006) $"
__revision__ = "Homework 2"
#    Copyright (C) 2006 by 
#    Seunghoon Kim <seunghoon@northwestern.edu>
#

import sys
import re
import glob

for pat in sys.argv[1:]:
	for file in glob.glob(pat):
		for para in open(file).read().split('\n\n'):
			dups = re.findall(r'(?m)(^.*(\b\w+\b)\s*\b\2\b.*$)', para)
			if dups:
				for dup in dups:
					print 'Duplicate word "%s" found in sequence: ' % dup[1], dup[0]						  

• urlizer.py - finds URL format in the string, and inserts HTML codes in the respective places

#!/usr/bin/env python
"""
Regular Expression II

"""
__author__ = """Seunghoon Kim (ski819)"""
__date__ = "$Date: 2006-04-17 (Mon, 17 Apr 2006) $"
__revision__ = "Homework 2"
#    Copyright (C) 2006 by 
#    Seunghoon Kim <seunghoon@northwestern.edu>
#


import re, fileinput

pattern = re.compile(r'''(?x)( # verbose identify URLs within text
	(http|ftp|gopher|mailto|telnet|file|wais) # make sure we find a resource type
	:* # ...needs to be followed by colon-slash-slash
	[^ \n\r]+ # some stuff then space, newline, tab is URL
	(\w+\.?){2,} # at least two domain groups, e.g. (gnosis.)(cx)
	(?=[\s\.,]) # assert: followed by whitespace/period/comma
	) # end of match group
	''')

#for line in fileinput.input():
if __name__ == '__main__':
	for line in fileinput.input():
		print re.compile(pattern, re.M).sub("<a href=\"\g<0>\">\g<0></a>", line.rstrip())

Extending Python 

#
#  Simple Makefile
#  For compiling C extension modules for 
#  python.
#

###################################################
#
# Basic Swig Procedure :~)
# 
# // First make the wrapper from the interface file
# swig -python utility.i
# // Then compile both the utility_wrap.c and the utility.c code.
# gcc -c utility.c utility_wrap.c -I/usr/include/python2.2
# // Then link :~)
# ld -shared utility.o utility_wrap.o -o _utility.so
#
##################################################

includes = -I/usr/include/python2.4 -I/usr/lib/python2.4
interface = *.i
source = *.c
objects = *.o
library = _example.so
junk = *.so *.o *_wrap.c *_wrap.doc
linkopts = -shared -o
ccopts = -c


${library} : ${objects} #pointer
	ld ${linkopts} ${library} ${objects}

${objects} : interface ${source} 
	gcc ${ccopts} ${source} ${includes}

interface : ${interface}
	swig -python ${interface}

clean :
	-rm ${junk}

#!/usr/bin/env python
"""
Extension Setup File

"""
__author__ = """Seunghoon Kim (ski819)"""
__date__ = "$Date: 2006-04-17 (Mon, 17 Apr 2006) $"
__revision__ = "Homework 3"
#    A Script written by 
#    Seunghoon Kim <seunghoon@northwestern.edu>
#

from distutils.core import setup, Extension

module = Extension('rankorder', sources = ['rankorder.c'])

setup (name = 'rank_order',
	   version = '1.0',
	   description = 'CS495-20 MP3',
	   ext_modules = [module])

#	Return a dictionary where
#	key = rank, ranked by number of occurrences
#	val = number of numbers at that rank
#	There may be more elegant ways to do this but
#	this is the most straightforward I could come up with.

import types

class RankBag(list):
	def __init__(self, list):
		self = list
		print self
	
	def rank(self):
		# Calculate the number of occurrences of a given number
		occurrences = {}
		for i in range(len(self)):
			occurrences[(self[i])] = occurrences.setdefault((self[i]), 0 ) + 1
		# Construct a decreasingly sorted sequence of
		# cnt, num pairs, first pair has rank 1
		self = [(cnt, num) for num, cnt in occurrences.items()]
		print self
		self.sort()
		print self
		self.reverse()
		print self
		return self
	
#	rank_counts = {}
#	current_rank = 1
#	current_cnt = pairs[0][0]
#	print current_cnt
	
	# Build the final dictionary, looking for transitions in
	# the counts for a number
#	for cnt, num in pairs:
#		print cnt, current_cnt
#		if cnt <> current_cnt:
#			current_rank = current_rank + 1
#			current_cnt = cnt
#		rank_counts[current_rank] = rank_counts.setdefault(current_rank, 0) + 1
		
#	print rank_counts
#	return rank_counts

// CS495-20 Homework 3
# include <stdio.h>
# include <stdlib.h>
# include <string.h>


//static PyObject* rank_order(PyObject *self, PyObject *args)
int rank_order(int argc, char **argv)
{

	char* nums = argv[1];
	int occurrences[10];
	int i, j, num;
	for (i=0; i<10; i++)
		occurrences[i] = 0;		
	for (num=0; num<10; num++)
	{
		for (i=0; i<strlen(nums); i++)
		{
			if (nums[i] == num)
				occurrences[num]++;
		}
	}
	
	int pairs[10];
	int tempswap;
	for (i=0; i<10; i++)
	{
		for(j=i; j<10; j++)
		{
			if (pairs[i] < pairs[j])
			{
				tempswap = pairs[j];
				pairs[j] = pairs[i];
				pairs[i] = tempswap;
			}
		}
	}
	
	int currcnt = 0;
	int countvalue = pairs[0];
	for(i=0; i<10; i++)
	{
		if (countvalue != pairs[i])
		{
			currcnt++;
			countvalue = pairs[i];
		}
	}
	int rank_counts[currcnt];

	countvalue = pairs[0];
	for(i=0; i<currcnt; i++)
		rank_counts[i] = 0;
	currcnt = 0;
	for(i=0; i<10; i++)
	{
		if (countvalue != pairs[i])
		{
			rank_counts[currcnt]++;
			currcnt++;
			countvalue = pairs[i];
		}
	}
	
	printf("{");
	for(i=0; i<currcnt; i++)
		printf("%d: %d,", i, rank_counts);
	printf("}");
	return 1;
}	

function rank_order(nums)

--	Return a dictionary where
--	key = rank, ranked by number of occurrences
--	val = number of numbers at that rank
--	There may be more elegant ways to do this but
--	this is the most straightforward I could come up with.
	
--	Calculate the number of occurrences of a given number
	occurrences = {}
	for num,nums do	
		occurrences[num] = occurrences.setdefault(num, 0) + 1
	end
		
--	Construct a decreasingly sorted sequence of
--	cnt, num pairs, first pair has rank 1
	pairs = [(cnt, num) for num, cnt in occurrences,items()]
	pairs.sort()
	pairs.reverse()
	
	rank_counts = {}
	current_rank = 1
	current_cnt = pairs[0][0]
	
--	Build the final dictionary, looking for transitions in
--	the counts for a number
	for cnt, num in pairs:
		if cnt ~= currenct_cnt:
			current_cnt = current_rank + 1
			current_cnt = cnt
		rank_counts[current_rank] = rank_counts.setdefault(current_rank, 0 ) + 1
		
	return rank_counts
end

Application Controller 

#!/usr/bin/env python
"""
Building a Remote iTunes Service

"""
__author__ = """Seunghoon Kim (ski819)"""
__date__ = "$Date: 2006-05-17 (Wed, 18 May 2006) $"
__revision__ = "Homework 4"
#    Copyright (C) 2006 by 
#    Seunghoon Kim <seunghoon@northwestern.edu>
#
#	 Executing python nettunes.py will trigger both functions.
#	 In order to modify arguments for the two functions, modify the last 3 lines of this code.
#	 Default values are host="wolverine", port=8080, seconds=20

import mytunes
import time

def average_track_length(remote_host, port):
	itunes = mytunes.MyTunes()
	itunes.start()
	try:
		tracks = itunes.track_length()
		count = len(tracks)
		total = sum(tracks)
		result = total/count
		return result
	except:
		print "Error retrieving tracks"

def needle_drop(remote_host, port, seconds):
	itunes = mytunes.MyTunes()
	try:
		tracks = itunes.track_length()
		count = len(tracks)
		itunes.play_track(0)
		for i in range(count):
			time.sleep(seconds)
			itunes.next_track()
			print "Playing next track"
	except:
		print "Error executing needle_drop"

print "Average track length:", average_track_length("wolverine", 8080)
print "Executing needle drop, will sample for 20 seconds"
needle_drop("wolverine", 8080, 20)

from appscript import *
import __builtin__

class MyTunes:
	def __init__(self):
		""" no arguments -> MyTunes handle
		creates a new MyTunes bridge object
		Save this value in a variable for future use, e.g.
		itunes = mytunes.MyTunes()
		"""
		self.__app = app('iTunes')
	
	def start(self):
		""" no arguments -> None
		starts iTunes playing"""
		try:
			self.__app.play()
		except:
			pass
		
	def pause(self):
		"""no arguments -> None
		pauses the currently  playing track
		"""
		try:
			self.__app.pause()
		except:
			pass
	
	def stop(self):
		"""no arguments -> None
		stops the currently playing track
		"""
		try:
			self.__app.stop()
		except:
			pass
	
	def next_track(self):
		""" no arguments -> None, 
		moves to the next track in the current playlist """
		try:
			self.__app.next_track()
		except:
			pass
	
	def previous_track(self):
		""" no arguments -> None
		moves to the previous track in the current playlist """
		try:
			self.__app.previous_track()
		except:
			pass
			
	def set_volume(self, value):
		"""integer between 0 and 100 -> None
		Sets the volume
		"""
		try:
			self.__app.sound_volume.set(value)
		except:
			print "Error setting volume. Skipping"
			pass
			
	def get_volume(self):
		"""no arguments -> integer
		Returns the current value of the volume setting
		"""
		try:
			return self.__app.sound_volume.get()
		except:
			return -1
		
	def play_playlist(self, pl_name):
		"""playlist_name -> None
		Starts playing the named playlist """
		try:
			pl = self.__app.playlists[pl_name]
			self.__app.play(pl)
		except:
			print "No such playlist %s" % pl_name
	
	def play_track(self, track_idx):
		"""track_name or number -> None
		Starts playing the indicated track, within the current playlist.
		"""
		try:
			tracks = self.__app.current_playlist.tracks.get()
			if track_idx >= len(tracks):
				print "Index out of bounds [0:%s)" % len(tracks)
				return
			track = tracks[track_idx]
			self.__app.play(track)
		except:
			print "No such track %s" % track_name
	
	def track_length(self):
		"""no arguments -> list of track_names, 
		Returns a list of strings for the currently playing playlist.
		"""
		try:
			tracks = self.__app.current_playlist.tracks.duration.get()
			return tracks
		except:
			print "Error retrieving tracks"
			
	def current_tracks(self):
		"""no arguments -> list of track_names, 
		Returns a list of strings for the currently playing playlist.
		"""
		try:
			tracks = self.__app.current_playlist.tracks.name.get()
			return tracks
		except:
			print "Error retrieving tracks"
			
	def current_track(self):
		"""no arguments -> dictionary
		Returns a dictionary of information
		regarding the current track
		"""
		
		track_fields = ['album', 'artist', 'bit_rate', 'bpm', 'comment',
				'compilation', 'composer', 'database_ID',
				'date_added', 'disc_count', 'disc_number',
				'duration', 'enabled', 'EQ', 'finish', 'genre',
				'grouping', 'kind', 'modification_date',
				'played_count', 'played_date',
				'rating', 'sample_rate', 'size', 'start',
				'time', 'track_count', 'track_number'
				'volume_adjustment', 'year',
				'name', 'location', 'container']
					
		try:
			result = {}
			track = self.__app.current_track.get()
			for field_name in track_fields:
				try:
					if hasattr(track, field_name):
						result[field_name] = getattr(track, field_name).get()
				except:
					pass
			return result
		except:
			print "Error getting track info."
			return result
	
	def track_info(self, track_name):
		"""track_name -> dictionary
		Returns dictionary of information regarding
		the named track if it exists, otherwise an empty dictionary
		"""
		
		try:
			track = self.__app.library_playlists.get()[0].tracks[track_name].get()
			track_fields = ['album', 'artist', 'bit_rate', 'bpm', 'comment',
				'compilation', 'composer', 'database_ID',
				'date_added', 'disc_count', 'disc_number',
				'duration', 'enabled', 'EQ', 'finish', 'genre',
				'grouping', 'kind', 'modification_date',
				'played_count', 'played_date',
				'rating', 'sample_rate', 'size', 'start',
				'time', 'track_count', 'track_number'
				'volume_adjustment', 'year',
				'name', 'location', 'container']
					
		
			result = {}
			for field_name in track_fields:
				try:
					if hasattr(track, field_name):
						result[field_name] = getattr(track, field_name).get()
				except:
					pass
			return result
		except Exception, e:
			print "Error getting track info"
			return {}
		
	def all_playlist_names(self):
		"""No arguments -> list of strings
		Returns a list of the names of all of the playlist
		names in the iTunes database."""
		
		try:
			return self.__app.sources['Library'].user_playlists.name.get()
		except:
			return []
			
	def all_track_names(self):
		"""No arguments -> list of strings, 
		Returns a list of the names of all of the track
		names in the iTunes database."""
		
		try:
			names = []
			for pl_name in self.all_playlist_names():
				tracks = self.__app.playlists[pl_name].tracks.get()
				if not tracks: continue
				names.extend(self.__app.playlists[pl_name].tracks.name.get())
			return names
		except Exception, e:
			print "Error", e
			return []
	
	def get_playlist(self, idx):
		"""playlist_name or playlist_number -> list of strings
		Returns a list of all the names in the named playlist, if the playlist exists.
		"""
		
		try:
			pl = self.__app.user_playlists[idx].get()
			results = []
			for track in pl.tracks.get():
				results.append(track.name.get())
			return results
		except:
			return []
			
	def __playlist_object(self, idx):
		try:
			playlists = self.__app.user_playlists.get()
			pl = None
			if isinstance(idx, str):
				pl = self.app.user_playlists[idx]
			elif isinstance(idx, int):
				if ((0 <= idx) and (idx < len(playlists))):
					pl = playlists[idx]		 
			return pl
		except:
			return
			
def help():
	for attr_name in dir(MyTunes):
		if attr_name[0] != "_":
			__builtin__.help(getattr(MyTunes, attr_name))

Embedding Python 

CS495 Python final project keynote