Programming in python

Convert html files to pdf

2009-08-12T22:21:00.000-07:00

#html2pdf.py
#
#Convert an html file into pdf. This script uses WebKit
#and runs on OS X 1.5
#
#Usage:
# python html2pdf.py <inputfile> <outputfile>
#
#Written using code from
#http://cocoadevcentral.com/articles/000074.php
#http://www.paulhammond.org/webkit2png

import WebKit
from Foundation import NSObject, NSMutableDictionary, NSURL, NSURLRequest
from AppKit import (NSPrintInfo, NSPrintSaveJob, NSPrintJobDisposition,
 NSPrintJobDisposition, NSPrintSavePath, NSPrintInfo,
 NSAutoPagination, NSApplication, NSWindow,
 NSBorderlessWindowMask)

class WebkitLoad (NSObject, WebKit.protocols.WebFrameLoadDelegate):
 def webView_didFinishLoadForFrame_(self,webview,frame):
 if (frame == webview.mainFrame()):
 self.printFrame(frame)

 def printFrame(self, frame):
 frameview = frame.frameView()
 sharedInfo = NSPrintInfo.sharedPrintInfo()
 sharedDict = sharedInfo.dictionary()
 printInfoDict = NSMutableDictionary.dictionaryWithDictionary_(
 sharedDict)
 printInfoDict.setObject_forKey_(NSPrintSaveJob,
 NSPrintJobDisposition);
 printInfoDict.setObject_forKey_(self.pdffile,
 NSPrintSavePath)

 printInfo = NSPrintInfo.alloc().initWithDictionary_(printInfoDict)
 printInfo.setHorizontalPagination_(NSAutoPagination);
 printInfo.setVerticalPagination_(NSAutoPagination);
 printInfo.setVerticallyCentered_(False);


 printOp = frameview.printOperationWithPrintInfo_(printInfo)
 printOp.setShowPanels_(False)
 printOp.runOperation()
 NSApplication.sharedApplication().terminate_(None)

def main(args):

 htmlfile=args[1]
 pdffile=args[2]
 rect = ((0, 0),(400, 400))

 app = NSApplication.sharedApplication()

 win = NSWindow.alloc()
 win.initWithContentRect_styleMask_backing_defer_ (rect,
 NSBorderlessWindowMask, 2, 0)

 webview = WebKit.WebView.alloc().init()
 webview.initWithFrame_(rect)

 url = NSURL.alloc().initFileURLWithPath_(htmlfile)
 request = NSURLRequest.alloc().initWithURL_(url)

 mainFrame = webview.mainFrame()
 mainFrame.loadRequest_(request)

 loaddelegate = WebkitLoad.alloc().init()
 loaddelegate.pdffile = pdffile
 webview.setFrameLoadDelegate_(loaddelegate)

 win.setContentView_(webview)

 app.run()

if __name__ == "__main__":
 import sys
 main(sys.argv)

Create a popup bookmarklet

2009-05-04T14:51:00.000-07:00

#buildbookmarklet.py
#
#Create a popup bookmarklet from some html content.
#
#eg.
#echo "<h1>Hello World</h1>" | python bookmarklet.py > out.html
#

import sys
import urllib
import optparse

usage = "python buildbookmarklet.py [options]"
parser = optparse.OptionParser(usage=usage)

parser.add_option("-l", "--length", type="int", dest="height",
 default=150, help="The height of the popup window.")
parser.add_option("-w", "--width", type="int", dest="width",
 default=350, help="The width of the popup window.")
parser.add_option("-t", "--title", type="string", dest="title",
 default='Bookmarklet',
 help="The title of the bookmarklet.")
(options, args) = parser.parse_args()

s = ('my_window= window.open ("","win","status=1,width=%i,height=%i");'
 'my_window.document.write(%s);'%
 (options.width, options.height, repr(sys.stdin.read())))

print """
<html>
<a href="javascript:%s">%s</a>
</html>
""" % (urllib.quote(s), options.title)

Create a mercurial mirror of an svn branch

2009-01-02T02:21:00.000-08:00

#hgsvnsync.py
#
#Create a mercurial mirror of a branch in an svn repository
#This scripts requires that the commands svn and hg be present
#in the path.
#
#Usage:
#To create a new mirror
# python hgsvnsync.py init svn_url mirror_location
#
#To update the mirror
# python hgsvnsync.py update mirror_location
#
# Changes
# 23-Jan-2009 Updated to working version.

import commands
import re
import os

hgignore= """syntax: regexp
[.]svn/
[.]hgignore
[.]commitmessage"""

def getRevisions(svn_url, frm=1):
    s = commands.getoutput('svn -r%s:HEAD log %s' % (frm, svn_url))
    return re.findall('------------------------------------------------------------------------\n'+
            'r(\d+) [|] \w+ [|] ', s)

def createFile(filename, content):
    f = file(filename, 'w')
    f.write(content)
    f.close()

def init(svn_url, dest):
    commands.getoutput('svn co -r1 %s %s' % (svn_url, dest))
    commands.getoutput('hg init %s' % dest)
    createFile(os.path.join(dest, '.hgignore'), hgignore)

def parseLog(log):
    (rev, commiter, date, lines) =  re.search(
        '------------------------------------------------------------------------\n'+
        'r(\d+) [|] (\w+) [|] ([^(]+)[^|]+[|] (\d+) line[s]?\n', log).groups()
    message = "%s\n\nSvn Revision %s" % (
                "\n".join(log.split('\n')[3:(3+int(lines))]),rev)
    return (rev, commiter, date, message)

def parseInfo(info):
    return dict(re.findall("(\w+): (.*)", info))

def commitRevs(svn_url, dest, frm):
    revs = getRevisions(svn_url, frm)[1:]
    for rev in revs:
        print "Commiting revision %s" % rev
        commands.getoutput('svn update -r%s %s' % (rev, dest))
        logMsg = commands.getoutput('svn log -rCOMMITTED %s' % dest)
        (rev, commiter, date, message) = parseLog(logMsg)
        commitmessagepath = os.path.join(dest, '.commitmessage')
        createFile(commitmessagepath, message)
        commands.getoutput("hg commit -A -l %s -d '%s' -u %s %s" %
                            (commitmessagepath, date, commiter, dest))

def main():
    import sys
    if sys.argv[1]=='init':
        svn_url = sys.argv[2]
        dest = sys.argv[3]
        init(svn_url, dest)
        commitRevs(svn_url, dest, 1)
    elif sys.argv[1]=='update':
        dest = sys.argv[2]
        info = parseInfo(commands.getoutput('svn info %s' % dest))
        rev = info['Revision']
        svn_url = info['URL']
        commitRevs(svn_url, dest, rev)

if __name__ == '__main__':
    main()

Creating a patch as a zip

2008-03-08T02:52:00.000-08:00

#diffdiff.py
# Create a zip file containing the difference between two directories.
# Usage: python dirdiff.py newdir olddir [outputfile]
# Files files in newdir that are different in olddir or are not present
# will be zipped. If the outputfile parameter is not  provided the a
# file diff.zip will be created.
#

from os import walk, stat
from os.path import join, sep, split
from sys import argv
from itertools import izip
from zipfile import ZipFile, ZIP_DEFLATED

def chop(base, path):
    if not base.endswith(sep):
        base = base + sep
    return path[len(base):]

def listfiles(path):
    for base, dirs, files in walk(path):
        for f in files:
            yield join(base, f)

def dirdiff(new_path, old_path, diff_file):
    zf = ZipFile(diff_file, "w")
    def write(file_path):
        zf.write(file_path, chop(new_path, file_path), ZIP_DEFLATED)
    for old, new in izip(walk(old_path), walk(new_path)):
        (old_base, old_dirs, old_files) = old
        (new_base, new_dirs, new_files) = new
        for d in set(new_dirs).difference(old_dirs):
            for f in listfiles(join(new_base, d)):
                write(f)
        for f in set(new_files).difference(old_files):
            write(join(new_base,f))
        fs = set(old_files) & set(new_files)
        ds = set(old_dirs) & set(new_dirs)
        old_dirs[:] = ds
        new_dirs[:] = ds
        for f in fs:
            file_old = join(old_base, f)
            file_new = join(new_base, f)
            if (stat(file_old).st_mtime != stat(file_new).st_mtime
                and file(file_old).read()!=file(file_new).read()):
                write(join(new_base, f))
    zf.close()

if __name__ == "__main__":
    new = argv[1]
    old = argv[2]
    if len(argv) == 4:
        out=argv[3]
    else:
        out="diff.zip"
    dirdiff(new, old, out)

Lisp in a single expression

2008-02-28T19:33:00.000-08:00

#lisp.py
#
#An interpreter for a simple scheme like lexically
#scoped language implemented as single python expression.
#
#The interpreter is limited to the lambda special form and a
#sum function. The data types supported are positive integers
#and symbols.
#

import re
from itertools import *
iterpreter = (lambda s: (
    (lambda g: lambda env, exp: g(g)(env, exp))
    (lambda g: (lambda interpret:(
        lambda env, exp:{
            list:lambda exp:(
                (exp[:1]==["lambda"]) and
                    (lambda env: lambda params:
                        (lambda nenv: [interpret(nenv, e)
                                for e in exp[2:]][-1])
                            (lambda x: dict(zip(exp[1], params)).get(x, False)
                                or env(x)))(env)
                or (lambda pexp: pexp[0](pexp[1:]))([interpret(env, e)
                    for e in exp])),
            str:lambda exp: env(exp), int:lambda exp: exp
        }[type(exp)](exp)))(lambda env, exp:g(g)(env, exp))))
        (lambda x:{"sum":(lambda params: sum(params))}.get(x, False),
        reduce(lambda env, v:
            (v==")" and
                (lambda:((lambda i:env[:i]+[env[i+1:]])
                    (len(env)-env[::-1].index("(")-1)))
            or (lambda:env+[v]))(),
                [(i==2 and int(e[i]) or e[i]) for e, i in
                    [(e,sum([c*(i is not "") for i, c in zip(e, count())]))
                        for e in re.findall(r"(\()|(\))|(\d+)|(\w+)",s)]],
                        [])[0]))

s = "((lambda (a b) (sum a (b))) 1 (lambda () 8))"
v = iterpreter(s)
print v

Count the number of on bits in a 32 bit integer

2007-09-04T09:10:00.000-07:00

#Count the number of on bits in in a 32bit integer
#

def bin2int(s):
    return sum(int(n)*2**i for i, n in zip(range(len(s)), s[::-1]))

def bitcount1(n):
    total = 0
    for i in range(32):
        total+=n&1
        n>>=1

masks = [(1,  '01010101010101010101010101010101'),
         (2,  '00110011001100110011001100110011'),
         (4,  '00001111000011110000111100001111'),
         (8,  '00000000111111110000000011111111'),
         (16, '00000000000000001111111111111111')]

masks = [(shift, bin2int(mask)) for shift, mask in masks]

def bitcount2(n):
    for shift, mask in masks:
        n = (n & mask) + (n>>shift & mask)
    return n

def bitcount3(n):
    mask = bin2int('00010001000100010001000100010001')
    total = 0
    for i in range(4):
        total+=(((n>>i&mask)*mask) >> 28)& 0xf
    return total

cleancvs.py

2007-07-08T06:12:00.000-07:00

#cleancvs.py
#
#Remove directories or files with the name CVS
#
#Doesn't check whether the file it is deleting is a cvs directory.
#And expects unix path seperators.
#
#usage:
#python cleancvs.py [path to clean]

import sys
import shutil

dir = sys.argv[1]

for basePath, files, directories in os.walk(dir):
if basePath.endswith("/CVS"):
shutil.rmtree(basePath)

Sieve of Eratosthenes

2007-05-27T21:08:00.000-07:00

#sieve.py
#
# The sieve of erasthosenes as an iterator
#
# eg.
#
# >>> from sieve import *
# >>> print(list(takeN(10, sieve()))
# [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

from itertools import count, takewhile, izip

def takeN(n, iter):
 for c, v in takewhile(lambda (c, v): c<=n,
 izip(count(1), iter)):
 yield v

def orF(fl, v):
 for f in fl:
 if f(v):
 return True
 return False

def sieve():
 isFactor = lambda p: lambda n: n%p==0
 l = []
 for i in count(2):
 if not orF(l, i):
 l = l + [isFactor(i)]
 yield i

Livejournal Flat Api

2007-02-18T23:20:00.000-08:00

#lj-api.py
#
# This a simple interface to livejournal's flat client/server protocol
#
#
# The documentation for the Client/Sertver protocols:
# http://www.livejournal.com/doc/server/ljp.csp.protocol.html
#
# The documentation for the flat Client/Server Protocol:
# http://www.livejournal.com/doc/server/ljp.csp.flat.protocol.html
#
#

import urllib2
import urllib
import md5
import re

def md5hex(s):
    m = md5.new()
    m.update(s)
    return m.hexdigest()

def doCall(args):
    request = urllib2.Request("http://www.livejournal.com/interface/flat", urllib.urlencode(args))
    resp = urllib2.urlopen(request)
    l = resp.read().split("\n");
    return dict(zip(l[::2], l[1::2]))


def _methodCall(methodname, username, passwordMD5, params):
    challenge = doCall({"mode":"getchallenge"})["challenge"]
    data = {
        "mode":methodname,
        "user":username,
        "auth_method":"challenge",
        "auth_challenge":challenge,
        "auth_response":md5hex(challenge+passwordMD5),
    }
    data.update(params)
    return doCall(data)

def getEvents(username, passwordMD5, **params):
    data = _methodCall("getevents", username, passwordMD5, params)

    r = re.compile("(events|prop)_(\\d+)_(\\w+)")
    events = [{} for i in range(int(data["events_count"]))]
    props = [{} for i in range(int(data["prop_count"]))]

    details = {"events":events}
    for name, value in data.items():
        match = r.match(name)
        if match:
            number = int(match.group(2))
            field = match.group(3)
            if match.group(1)=="events":
                events[number-1][field] = value
            else:
                props[number-1][field] = value
        else:
            details[name] = value

    propdict = {}
    for prop in props:
        itemid = prop['itemid']
        name = prop['name']
        value = prop['value']
        propdict.setdefault(itemid, {})[name] = value
    print propdict.keys()
    print [event['itemid'] for event in events]
    for event in events:
        eventprops = propdict.get(event.get('itemid'),{})
        event.update(eventprops)
    return details

def addEvent(username, passwordMD5, event):
    params = {
        "subject":subject,
        "event":parse(event)
    }
    data = _methodCall("postevent", username, passwordMD5)


def editEvent(username, passwordMD5, event):
    pass

if __name__ == '__main__':
    username = someUsername
    passwordMD5 = somePassword
    params = {
        "noprops":"0",
        "selecttype":"lastn",
        "howmany":"20",
        "truncate":"100"
    }
    info = getEvents(username, passwordMD5, **params)
    print info.keys()
    events = info["events"]
    for title in [event.get('subject', event['event'])
                  for event
                  in events]:
        print title
    print events[0]

Working with excel column labels

2006-10-29T11:08:00.000-08:00

#excelize.py
#
#A module containing some helper methods to work with
#excel column label formated numbers.
#Excel and other spreadsheets use a wierd format for their column
#numbering. It is of the form A, B, ..., Y, Z, AA, AB, ..., AZ, BA, ...
#
#See Excel Numbering/Counting
#
#Changes:
#30/10/2006 - Got rid of the inner methods in excelize and deExcelize

def chars():
    """
    Returns an iterator object that yields each charector of the
    english alphabet in capitals.
    """
    for i in range(26):
        yield chr(65 + i)

def excelIter():
    """
    Returns an iterator that yields each excel formated column
    number in ascending order.
    """
    for ch in chars():
        yield ch
    for exCh in excelIter():
        for ch in chars():
            yield exCh+ch

def excelize(n):
    """
    Returns excel formated column number for n

    Expects an int value greater than 0.
    """
    n-=1
    div = n/26
    if div==0:
        return chr(65+n)
    else:
        return excelize(div)+chr(65+n%26)

def deExcelize(s):
    """
    Returns an integer value for an excel formated column value

    Expects a string containing only capital letters from the
    english alphabet.
    """
    rem = s[:-1]
    if rem == "":
        return ord(s) - 64
    else:
        return 26*deExcelize(s[:-1]) + ord(s[-1]) - 64

Replacing spaces with dots for formatting code in coments

2006-10-29T10:57:00.000-08:00

#dotify.py
#
#Insert dots instead of spaces and tabs
#in the begining of lines. This is to
#maintain formatting for code while
#commenting in sites that do not support
#formatting.
#
#usage:
#cat test.py | python dotify.py >> dotted.txt
#

import re
import sys
r = re.compile("^[ \t]+", re.MULTILINE)

def repFun(match):
return "."*len(match.group().replace("\t", " "*4))

print r.sub(repFun, sys.stdin.read())

Records and pattern matching

2005-10-18T06:59:00.000-07:00

##record.py
##
##"record" is an implementation of a simple record
##type constructor for records with labeled fields.
##The record types will be subclasses of "tuple".
##
##"match" is a pattern matcher for matching patterns
##of complex record structures to a record object and
##binding elements in the matched structure to parameters
##in a handler function.
##
##Example:
##from record import record, match, sym
##tree = record(sym.tree, sym.left, sym.right)
##def flatten(t):
## return (match(t).
## case(tree(sym.left, sym.right),
## lambda left, right: flatten(left)+flatten(right)).
## case(sym.leaf, lambda leaf: [leaf])
## ())
##
##t = tree(tree(1, tree(2, 4)), 3)
##print flatten(t)
##prints:
##[1, 2, 4, 3]

class symbol(object):
 """
 Symbols for place holders for pattern matching
 """
 syms = {}

 def __new__(kls, name):
 if name in symbol.syms:
 return symbol.syms[name]
 else:
 o = object.__new__(kls)
 symbol.syms[name] = o
 return o

 def __init__(self, name):
 self.name = name

 def __str__(self):
 return self.name

 def __repr__(self):
 return self.name

class _symbol(object):
 def __getattribute__(self, name):
 return symbol(name)

sym = _symbol()

def record(name, *labels):
 """
 Construct a record type. Records are subclasses of tuple:
 <new record class> = record(name, label1, ...)

 Usage:
 user = record(sym.user, sym.name, sym.password)
 ram = user(name="ram", password="*****")
 shyam = user("shyam", "*")
 print "ram's name = ", ram.name
 name, password = ram
 """
 labels = [str(label) for label in labels]
 name = str(name)
 def new(kls, *labels):
 return tuple.__new__(kls, labels)
 def __str__(self):
 return "%s(%s)" % (name,
 ", ".join(("%s=%s"%(label, val)
 for label, val
 in zip(labels, self))))
 d = {"__new__":new,
 "__str__":__str__,
 "__repr__":__str__}
 exec ("""def __init__(self, %s):pass""" %
 ", ".join(labels)) in d

 for i in range(len(labels)):
 d[labels[i]] = (lambda i:
 property(lambda self:
 self[i]))(i)

 return type(name, (tuple,), d)

def _combine(obj, pattern):
 if isinstance(pattern, symbol):
 return [(str(pattern), obj)]
 elif isinstance(pattern, tuple) and type(obj)==type(pattern):
 return sum((_combine(o, p) for o, p in zip(obj, pattern)), [])
 elif pattern == obj:
 return []
 else:
 return False

class MatchFailed(Exception):pass

class match(object):
 """
 Match the given object and do some actions
 """
 def __init__(self, obj):
 self.obj = obj
 self.matchers = []
 def onDefault(obj):
 raise MatchFailed
 self._onDefault = onDefault

 def case(self, pattern, onMatch):
 """
 Add a match case.

 The match case matches a pattern to an action
 """
 self.matchers.append((pattern, onMatch))
 return self

 def default(self, onDefault):
 """
 Set a default handler if all matches fail.

 The handler must accept one parameter which
 will be the match object.
 """
 self._onDefault = onDefault

 def __call__(self):
 """
 Execute the match
 """
 for pattern, onMatch in self.matchers:
 c = _combine(self.obj, pattern)
 if c!=False:
 return onMatch(**dict(c))
 self._onDefault(self.obj)

Two way iterator

2005-10-14T10:03:00.000-07:00

#twowayiterator.py
#
#Helpers for implementing iterators
#that can be talked to
#
#See:
#http://blogs.applibase.net/sidharth/?p=30
#

def izip(*args):
 """
 A special version of izip
 that continues processing the
 remaining iterators one more
 time even after the one of them
 has thrown StopIteration.
 """
 iters = [arg for arg in args]
 canloop = True
 while canloop:
 l = []
 for it in iters:
 if canloop:
 try:
 l.append(it.next())
 except StopIteration:
 canloop = False
 else:
 try:
 it.next()
 except StopIteration:
 pass
 if canloop:
 yield l

class _Ref:
 def put(self, val):
 self.val = val
 def get(self):
 return val

class _Ret:
 def set(self, val):
 self.val = val
 raise StopIteration

 def get(self):
 return self.val

def twowayiterator(generator):
 """
 A decorator for generators for iterators
 that can get messages from the caller.

 Building a generator:
 @twowayiterator
 def <generator_name>((ret, get), <params>):
 ...
 yield <value>
 <var>=get()
 ...
 ret(<value>)

 ret and get are required parameters for the decorator
 get is used to return the value injectd into the
 iterator by its caller.
 yield <value>
 <var>=get()
 could be considered to represent
 <var>=yield<value>

 ret is used to signal that the iterator is done and
 return a value to its caller.
 ret(<value>)
 could be represented as
 return <value>

 Using a two way iterator
 (ret, put), iter = <generator_name>(<params>)
 try:
 ...
 put(<value>)
 <var>=iter.next()
 ...
 except StopIteration:
 ...
 <var>=ret()

 put is used to inject a value into the iterator
 it is the other side of the get function
 put(<value>)
 <var>=iter.next()
 can be represented as
 <var>=iter.next(<value>)

 ret in this case case is different from ret in the
 iterator it is used to recieve a value returned
 using ret.

 The two way iterator could be used in a for loop

 (ret, put), iter = <generator_name>(<params>)
 for val in iter:
 ...
 put(<value>)
 <var>=ret()
 """
 def _twowayiterator(*args, **aargs):
 _in = _Ref()
 ret = _Ret()
 return ((ret.get, _in.put),
 generator((ret.set, _in.get),
 *args, **aargs))
 return _twowayiterator

Tree Function examples

2005-10-12T12:50:00.000-07:00

#trees.py
#
#See Roshan's blog
#

from itertools import izip

class Node:
    def __init__(self, left, right):
        self.left = left
        self.right = right

    def __str__(self):
        return "Node(%s, %s)"%(self.left, self.right)

def flatten(node):
    """
    Flatten the tree depth first from the left to right.
    """
    if isinstance(node, Node):
        for i in flatten(node.left):
            yield i
        for i in flatten(node.right):
            yield i
    else:
        yield node

def samefringe(tree1, tree2):
    """
    Check whether two trees have the same leaf nodes
    with the same value.
    """
    for leaf1, leaf2 in izip(flatten(tree1), flatten(tree2)):
        if leaf1!=leaf2:
            return False
    return True

def repmin(tree):
    """
    Return a new tree in with the same node structure
    but all leaf nodes have the same value which is the
    minimum leaf value.
    """
    minval, f = _repmin(tree)
    return f(minval)

def _repmin(tree):
    if isinstance(tree, Node):
       (minleft, left) = _repmin(tree.left)
       (minright, right) = _repmin(tree.right)
       return (min(minleft, minright),
               lambda minval: Node(left(minval), right(minval)))
    else:
        return (tree, lambda val: val)

tree1 = Node(1, Node(2, Node(3, Node(4, 5))))
tree2 = Node(Node(1, Node(2, 3)), Node(4, 5))
tree3 = Node(Node(1, Node(2, 4)), Node(4, 5))

print samefringe(tree1, tree2)
print samefringe(tree1, tree3)

print repmin(tree1)

An introduction to python classes

2005-04-18T02:53:00.000-07:00

#class_examples.py
#
#Theses examples were used in a talk I
#gave at the BangPipers meeting on
#16/04/2005

#Starting with an empty class
class Greeter(object):
 pass

#Lets add a simple method
def meth(self):
 print "this is a method of class ", self.__class__

simpleobject = Greeter()

Greeter.meth = meth

simpleobject.meth()

Greeter.meth(simpleobject)
#Prints:
#this is a method of class <class '__main__.Greeter'>

#An init method for our greeter class
def init(self, text):
 self.text = text

Greeter.__init__ = init

greeting = Greeter("Greetings from the great beyond")

print greeting.text
#Prints:
#Greetings from the great beyond

#Adding a greet method to print the greeting text
def greet(self):
 print self.text

Greeter.greet = greet

greeting.greet()
#Prints:
#Greetings from the great beyond

#Now lets inherit from Greeter to create
#a Hello greeting
class Hello(Greeter):
 def __init__(self):
 self.text = "Hello"

hello = Hello()

hello.greet()
#Prints:
#Hello

#Overloading __new__ to control instance creation
#__new__ gets called before __init__ during
#instance creation.
#FussyGreeter will return an insult object if
#os.platform is not "win32"
class FussyGreeter(Greeter):
 acceptedPlatform = "win32"
 def __new__(cls, greeting):
 import sys
 if cls.acceptedPlatform != sys.platform:
 class Insult(object):
 def greet(self):
 print "You call that an OS?!? Get a real one like", cls.acceptedPlatform
 return Insult()
 else:
 return Greeter.__new__(cls)

greet = FussyGreeter("Howdy")

greet.greet()
#Prints:
#Howdy

FussyGreeter.acceptedPlatform = "linux"

greet = FussyGreeter("Howdy")

greet.greet()
#Prints:
#You call that an OS?!? Get a real one like linux

print type(greet)
#Prints:
#<class '__main__.Insult'>

#Checking call order for __new__ and __init__
#Note:If __new__ returns anything other than an obect
#of type SimpleClass, __init__ will not be called.
class SimpleClass(object):
 def __init__(self):
 print "calling __init__(%s)"%self


 def __new__(cls):
 print "calling __new__(%s)"%cls
 return object.__new__(SimpleClass)

simpleobject = SimpleClass()
#Prints:
#calling __new__(<class '__main__.SimpleClass'>)
#calling __init__(<__main__.SimpleClass object at 0x011AB650>)

#Here is a simple example of operator overloading
#We overload the '*' operator.
def mul(self, count):
 text = self.text
 if text[-1] == "s":
 endString = ""
 else:
 endString = "s"
 return Greeter("%i %s" % (count, text) + endString)

Greeter.__mul__ = mul

doubleHello = hello * 2

doubleHello.greet()
#Prints:
#2 Hellos

print doubleHello
#Prints:
#<__main__.Greeter object at 0x011AB330>

#We can write an __str__ method to control
#what gets printed
def str_(self):
 return self.text

Greeter.__str__ = str_

print doubleHello
#Prints:
#2 Hellos

#multiple inheritence
#mro
#super
class A(object):
 def f(self):
 print "A.f(inst)"

class B(A):
 def f(self):
 print "B.f(inst)"
 super(B, self).f()

class C(A):
 def f(self):
 print "C.f(inst)"
 super(C, self).f()

class D(B, C):
 def f(self):
 print "D.f(inst)"
 super(D, self).f()

d = D()
print d.__class__.mro();
#Prints:
#[<class '__main__.D'>, <class '__main__.B'>,
#<class '__main__.C'>, <class '__main__.A'>, <type 'object'>]

d.f()
#Prints:
#D.f(inst)
#B.f(inst)
#C.f(inst)
#A.f(inst)

#We can control attribute access for an
#object by overriding the methods
#__getattr__ and __setattr__
class attrdict(dict):
 def __getattr__(self, name):
 return self[name]

 def __setattr__(self, name, value):
 self[name] = value

d = attrdict()

d.a = 4
#Same as d.__setattr__("a", 4)

print d.a
#Same as print d.__getattr__("a")

#__getattr__ only gets called if python is
#unable to find the attribute name withen the object
#and its class
#This means that if I assign an attribute with the same name
#as one in dict

d.fromkeys = "hello"

#I wont be able to access the value
print d.fromkeys
#Prints:
#<built-in method fromkeys of type object at 0x01217828>

#We need to overload __getattribute__ to get complete controll
#over attribute lookup
def getattribute(self, name):
 return dict.__getitem__(self, name)

attrdict.__getattribute__ = getattribute

print d.fromkeys
#Prints:
#hello

#__slots__

#Class magic

#Classes in python are code objects that get executed when
#they are loaded.
#Lest look at some examples

class HelloWorld:
 print "hello world"
#Prints:
#hello world

#Something illegal
class ManyVars:
 for i in range(26):
 locals()[chr(i+97)] = i
print dir(ManyVars)
#Prints:
#['__doc__', '__module__', 'a', 'b', 'c', 'd', 'e',
#'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
#'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
#'y', 'z']

#Legal using exec
class ManyVars:
 for i in range(26):
 exec "%s = %i" % (chr(i+97), i)
print dir(ManyVars)
#Prints:
#['__doc__', '__module__', 'a', 'b', 'c', 'd', 'e',
#'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
#'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
#'y', 'z']

#Metaclasses
#Meta classes are class constructors
#A meta class must accept a classname,
#a tuple of base classes and a dictionary
#of name value pairs representing the
#class's attributes and their values.

#Lets create a simple class and extract
#all its local name bindings into a global
#variable called l
class C:
 def __init__(self):
 self.text = "Namaste"
 global l
 l = locals()

print l
#Prints:
#{'__module__': '__main__', '__doc__': None,
#'__init__': <function __init__ at 0x011E03B0>}

#We can use type as a class constructor to
#construct a class called Namaste which is
#a subclass of Greeter and contains attributes
#defined in l
Namaste = type("Namaste", (Greeter,), l)

namaste = Namaste()

namaste.greet()
#Prints:
#Namaste

#Lets create a simple empty class
SimpleClass = type("SimpleClass", (), {})

simpleInstance = SimpleClass()

print simpleInstance
#Prints:
#<__main__.SimpleClass object at 0x011DE2F0>

#Metaclasses are the same as other classes
#What makes them special is that they are
#all subclasses of type

#Lets look at the call order of the __new__ and __init__
#methods of a simple metaclass
class PrintingMetaclass(type):
 def __init__(self, name, bases, dct):
 print "calling __init__"
 return type.__init__(self, name, bases, dct)
 def __new__(cls, name, bases, dct):
 print "calling __new__"
 return type.__new__(cls, name, bases, dct)

SimpleClass = PrintingMetaclass("SimpleClass", (), {})
#Prints:
#calling __new__
#calling __init__

#We can also set the metaclass for a particular
#clas int using the class attribute __metaclass__
class SimpleClass:
 __metaclass__ = PrintingMetaclass


#Prints:
#calling __new__
#calling __init__

#Here's an example of metaclasses in action
_securityNumbers = [1,2,3]

class SecurityMetaclass(type):
 def __new__(self, name, bases, dct):
 import types
 for (name, value) in dct.items():
 if isinstance(value, types.FunctionType):
 def func(self, securityNumber, *args, **kwargs):
 if securityNumber in _securityNumbers:
 return value(self, *args, **kwargs)
 else:
 raise Exception, "You are not authorized to call this method"
 dct[name] = func
 print dct
 return type.__new__(self, name, bases, dct)

class SecureClass(object):
 __metaclass__ = SecurityMetaclass
 def display(self, value):
 print value

secureObject = SecureClass()

secureObject.display(1, "This is a secret message.")
#Prints:
#This is a secret message.

#secureObject.display(7, "This is a secret message.")
#Will throw an exception

#Descriptors
#__get__(self, obj, type)
#__set__(self, obj, value)
#__delete__(self, obj)

#Lets create a class to work with
class DiscrExp(object):pass
inst = DiscrExp()

#Here is a simple example of properties
#in python
def fset(self, value):
 self.value = value*2

def fget(self):
 return self.value

DiscrExp.doublingValue = property(fget, fset)

inst.doublingValue = 2
print inst.doublingValue
#Prints:
#4

#Lets create a printing discriptor to see how
#the different methods of a descriptor are
#called
class PrintingDiscriptor(object):
 def __get__(self, obj, type):
 print "__get__"
 print "obj = ", obj
 print "type = ", type

 def __set__(self, obj, value):
 print "__set__"
 print "obj=", obj
 print "value=", value

 def __delete__(self, obj):
 print "__delete__"
 print "obj=",obj

DiscrExp.pd = PrintingDiscriptor()
inst.pd
#Prints:
#__get__
#obj = <__main__.DiscrExp object at 0x011AB890>
#type = <class '__main__.DiscrExp'>

inst.pd = 5
#Prints:
#__set__
#obj= <__main__.DiscrExp object at 0x011AB890>
#value= 5

DiscrExp.pd
#Prints:
#__get__
#obj = None
#type = <class '__main__.DiscrExp'>

#Creating a static method descriptor
class StaticMethod(object):
def __init__(self, f):
 self.f = f
def __get__(self, obj, type):
 return self.f

def warning():
 print "This is a universal warning, for this class only"

DiscrExp.warning = staticmethod(warning)
DiscrExp.warning()

#Prints:
#This is a universal warning, for this class only

inst.warning()
#Prints:
#This is a universal warning, for this class only

#References:
#http://www.python.org/2.2.3/descrintro.html
#http://users.rcn.com/python/download/Descriptor.htm
#Python in a nutshell 2nd ed.

A pass by reference decorator

2005-04-05T23:00:00.000-07:00

#passbyref.py
#
#Implementing pass by reference operations
#in python.
#
#Exanple
#python passbyref.py
#>>>@passbyreference(sym.b)
#...def func(a):
#...    a.set("hello")
#>>>
#>>>v = 5
#>>>func(1, sym.v, 3)
#>>>print v
#hello
#

import inspect

class _symbol(object):
    def __getattribute__(self, name):
        return name
sym = _symbol()

class ref:
    def __init__(self, value):
        self.value = value

    def set(self, value):
        self.value = value

    def get(self):
        return self.value

    def __repl__(self):
        return "ref(%s)" % self.value

    def __str__(self):
        return self.value


def passbyreference(*refparams):
    def getfunc(func):
        fc = func.func_code
        paramcount = fc.co_argcount
        paramnames = list(fc.co_varnames[:paramcount])
        def pbr(*args, **aargs):
            callerLocals = inspect.currentframe(1).f_locals
            callerRefVars = []
            argsMap = {}
            argsMap.update(dict(zip(paramnames[:len(args)], args)))
            argsMap.update(aargs)
            for paramName in refparams:
                varName = argsMap[paramName]
                varRef = ref(callerLocals[varName])
                argsMap[paramName] = varRef
                callerRefVars.append((varName, varRef))

            retval = func(**argsMap)

            for varName, varRef in callerRefVars:
                callerLocals[varName] = varRef.get()
            return retval
        return pbr
    return getfunc

Dylan style multiple dispatch

2005-03-30T14:12:00.000-08:00

#generic.py
#multimethods in python
#
#Example:
#>>> @generic(int)
#... def reverse(next_func, n):
#... return str(n)[::-1]
#...
#>>> @generic(str)
#... def reverse(next_func, s):
#... return s[::-1]
#...
#>>>reverse("hello")
#'olleh'
#>>>reverse(1234)
#4321
#Changes:
#31-Mar-2005: Fixed a bug in the dispatch, which ment
# that the best option might not be selected
# multiple inheritence situations.

_genericmethods = {}

def _issuitable(pts, pts_):
 for pt, pt_ in zip(pts, pts_):
 if not issubclass(pt, pt_):
 return False
 return True

def _closer(pts, (fn1, pts1), (fn2, pts2)):
 for pt, pt1, pt2 in zip(pts, pts1, pts2):
 mro = pt.mro()
 score1 = mro.index(pt1)
 score2 = mro.index(pt2)
 if score1 < score2:
 return (fn1, pts1)
 if score2 < score1:
 return (fn2, pts2)
 return (fn1, pts1)

def generic(*paramtypes):
 def generic_(func):
 key = (func.__name__, len(paramtypes))
 functions = _genericmethods.setdefault(key, [])
 functions.append((func, paramtypes))
 def next_method(suitable, params, pts):
 if len(suitable)==0:
 raise Exception, "Unable to match generic method"
 else:
 best = suitable[0]
 for cur in suitable:
 best = _closer(pts, best, cur)
 suitable = suitable[:]
 suitable.remove(best)
 func, pts_ = best
 return func(lambda *params:next_method(suitable, params, pts), *params)

 def first_call(*params):
 pts = [type(param) for param in params]
 suitable = [(fn_, pts_)
 for fn_, pts_ in functions
 if _issuitable(pts, pts_)]
 return next_method(suitable, params, pts)
 return first_call
 return generic_

Symbolic Expressions in python

2005-03-09T17:37:00.000-08:00

#symbolic.py
#
#This is a python module to represent symbolic expressions
#
#>>>a = sym("a")
#>>>b = sym("b")
#>>>print eq(a + b, 5 * -b * b* b + 5)
#((a+b)=((((5*-b)*b)*b)+5))

class opp:
    """
    Base class for all operators and the symbolc class
    """
    def __getattr__(self, attr):
        if attr[:2] == "__" and attr[-2:] == "__":
            funcname = attr[2:-2]
            if funcname in operators:
                return lambda *x: operators[funcname](self, *x)
            elif funcname[0]=='r' and funcname[1:] in operators:
                return lambda x: operators[funcname[1:]](x, self)
        raise ("AttributeError: object '%s' has no attribute '%s'" %
               (repr(self), attr))

    def __coerce__(self, other):
        return None

class sym(opp):
    """
    Symbols are used as variables in equations
    """
    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return "sym("+self.name+")"

    def __str__(self):
        return self.name

class binopp(opp):
    """
    This is base class for defining binary operators
    """
    def __init__(self, lhs = None, rhs = None):
        self.lhs = lhs
        self.rhs = rhs

    def __str__(self):
        return "("+str(self.lhs)+self.operator+str(self.rhs)+")"

    def __repl__(self):
        return self.operator+"("+repl(self.lhs)+", "+repl(self.rhs)+")"

class uniopp(opp):
    """
    This is the base class for unary operators
    """
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return self.operator+str(self.value)

    def __repr__(self):
        return self.operator+"("+repr(self.value)+")"

#Operator definitions
class eq(binopp): operator = "="
class add(binopp): operator = "+"
class sub(binopp): operator = "-"
class div(binopp): operator = "/"
class mul(binopp): operator = "*"
class neg(uniopp): operator = "-"

operators = {"add":add, "sub":sub, "div":div,"mul":mul, "neg":neg}

A simple scheme interpreter

2005-02-23T09:36:00.000-08:00

#scheme.py
#This is a implementations of an intrepreter
#for a small subset of scheme.
#
#What it has:
#Commands
# Look at the function 'eval'
#Functions
# look at the dictionary 'predefineds'
#
#Examples:
#1)Fibonacci numbers
#python scheme.py
#>>>(define fibonacci
#... (lambda (n)
#... (define fib
#... (lambda (n1 n2 cnt)
#... (if (= cnt n)
#... n1
#... (fib n2 (+ n1 n2) (+ cnt 1)))))
#... (fib 0 1 0)))
#>>>(display (fibonacci 10))
#55
#>>>
#
#2)Coroutines
#python scheme.py
#>>>(define list (lambda l l))
#>>>(define message
#... (lambda (cont msg)
#... (call/cc
#... (lambda (newCont)
#... (cont (cons newCont msg))))))
#>>>(define f
#... (lambda (fname cont msg)
#... (display (cons fname msg))
#... (define msgList (message cont (+ 1 msg)))
#... (f fname (car msgList) (cdr msgList))))
#>>>(define msg
#... (call/cc (lambda (cont)
#... (f "f1:" cont 1))))
#>>>(f "f2" (car msg) (cdr msg))
#
#Changes;
#24-Feb-2005 Added quote and the quote symbol '
#25-Feb-2005 Fixed a bug with begin
#25-Feb-2005 Added eval
#25-Feb-2005 Added py-eval and py-exec

#Uncomment the following line if you are using python 2.2
#from __future__ import generators
import re

py_context = {}
py_eval_func = eval

class context:
 def setVars(self, names, values):
 if names == None:
 return
 elif isinstance(names, symbol):
 self.vars[str(names)] = values
 else:
 (name, restNames) = names
 (value, restValues) = values
 self.vars[str(name)]=value
 self.setVars(restNames, restValues)

 def __init__(self, parent, var_names = None, values = None):
 self.parent = parent
 self.vars = {}
 self.setVars(var_names, values)

 def get(self, var_name):
 if self.vars.has_key(var_name):
 return self.vars[var_name]
 elif self.parent != None:
 return self.parent.get(var_name)
 else:
 raise KeyError("Unknown variable "+var_name)

 def set(self, var_name, value):
 if self.vars.has_key(var_name):
 self.vars[var_name] = value
 elif self.parent != None:
 return self.parent.set(var_name, value)
 else:
 raise Key("Unknown variable " + var_name)

 def define(self, var_name, value):
 self.vars[var_name] = value


class symbol:
 def __init__(self, value):
 self.value = value

 def __str__(self):
 return self.value

 def __repr__(self):
 return "symbol('"+self.value+"')"

 def __eq__(self, value):
 if isinstance(value, symbol):
 return self.value == value.value
 else:
 return False

# Predefined Symbols (can't be redefined)
LAMBDA = symbol("lambda")
IF = symbol("if")
BEGIN = symbol("begin")
SET = symbol("set!")
DEFINE = symbol("define")
LOAD = symbol("load")
QUOTE = symbol("quote")

#The tokenizer

#Token Types
OPENBRACKET = 0
CLOSEBRACKET = 2
ATOM = 3
SYMBOL = 4
DOT = 5
SINGLE_QUOTE = 6

tokens_re = re.compile(r'\(|\)|(?:[\w+\-*/<>=!?.]+)|'+
 r'(?:"(?:[^"]|\\")+")|'+
 r'(?:#(?:t|f|(?:\\(?:newline|space|.))))|'+
 r'\'')
def tokenize(code):
 """This is a very simple tokenizer,
 it accepts a string that represents
 the code an returns a list of
 token type, token paris"""

 tokens = tokens_re.findall(code)
 for token in tokens:
 if token == "(":
 yield (OPENBRACKET, token)
 elif token == ")":
 yield (CLOSEBRACKET, token)
 elif token == ".":
 yield (DOT, token)
 elif token == "'":
 yield (SINGLE_QUOTE, token)
 elif token.isdigit():
 yield (ATOM, int(token))
 elif token[0]=='"':
 yield (ATOM, token[1:-1].replace(r'\\', "\\").replace(r'\"', r'"'))
 elif token[0]=="#":
 if token[1]=="\\":
 char = token[2:]
 if char == "space":
 char = " "
 if char == "newline":
 char = "\n"
 yield (ATOM, char)
 elif token[1]=="t":
 yield (ATOM, True)
 elif token[1]=="f":
 yield (ATOM, False)
 else:
 raise Exception("Invalid token "+ token)
 else:
 yield (SYMBOL, symbol(token))


#S-Espressions
def process_sexpr(tokens):
 token_type, value = tokens.next()
 if token_type == SINGLE_QUOTE:
 return [QUOTE, [process_sexpr(tokens), None]]
 elif token_type == OPENBRACKET:
 cons = [None, None]
 lst = cons
 token = None
 while True :
 token = process_sexpr(tokens)
 if token not in [")", "."]:
 cons[1] = [token, None]
 cons = cons[1]
 else:
 break
 if token == ".":
 cons[1] = process_sexpr(tokens)
 token_type, token = tokens.next()
 if token == ")":
 return lst[1]
 else:
 raise Exception("expected close bracket for expression "+
 str(lst)+token)
 else:
 return value

def sexpr(text):
 return process_sexpr(tokenize(text))

def sexprs(text):
 """Build an s-expression from a string"""
 lst = [None, None]
 cur = lst
 tokens = tokenize(text)
 try:
 while True:
 cur[1] = [process_sexpr(tokens), None]
 cur = cur[1]
 except StopIteration:
 pass
 return lst[1]



#Pedefined Functions

#Convert a python function into a form
#suitable for the interpreter
def predefined_function(function):
 def func(continuation, args):
 argList = []
 while args!=None:
 arg, args = args
 argList.append(arg)
 return continuation, function(*argList)
 return func

#Some basic predefined functions

def display(obj):
 print obj

def callcc(continuation, args):
 (func, nil) = args
 def cont_func(cont, (arg, nil)):
 return (continuation, arg)
 return func(continuation, (cont_func, None))

def gen_eval(context):
 def eval_func(continuation, arg):
 expr, nil = arg
 return (eval_continuation(continuation, context, expr), None)
 return eval_func

def py_exec(continuation, arg):
 code, nil = arg
 exec code in py_context
 return (continuation, None)

def py_eval(continuation, arg):
 code, nil = arg
 return (continuation, py_eval_func(code, py_context))


global_context = context(None)

predefineds = {"+":predefined_function(lambda *args:sum(args)),
 "*":predefined_function(lambda *args:reduce(int.__mul__, args)),
 "-":predefined_function(lambda a, b:a - b),
 "<":predefined_function(lambda a, b:a < b),
 ">":predefined_function(lambda a, b:a > b),
 "=":predefined_function(lambda a, b:a == b),
 "cons":predefined_function(lambda a, b:[a, b]),
 "car":predefined_function(lambda(a, b):a),
 "cdr":predefined_function(lambda(a, b):b),
 "display":predefined_function(display),
 "call-with-current-continuation":callcc,
 "call/cc":callcc,
 "eval":gen_eval(global_context),
 "py-exec":py_exec,
 "py-eval":py_eval}

global_context.vars = predefineds

#Eval

#A continuation for the evaluation of an expression
class eval_continuation:

 def __init__(self, continuation, context, expr):
 self.next = continuation
 self.context = context
 self.expr = expr

 def run(self, val):
 return eval(self.next, self.context, self.expr)

def eval_str(continuation, context, code):
 if isinstance(code, str):
 code = sexpr(code)
 return eval(continuation, context, code)

#The eval method
def eval(continuation, context, code):
 if isinstance(code, list):
 if code[0] == LAMBDA:
 return eval_lambda(continuation, context, code)
 elif code[0] == IF:
 return eval_if(continuation, context, code)
 elif code[0]== BEGIN:
 return eval_begin(continuation, context, code)
 elif code[0] == DEFINE:
 return eval_define(continuation, context, code)
 elif code[0] == SET:
 return eval_set(continuation, context, code)
 elif code[0] == QUOTE:
 return eval_quote(continuation, context, code)
 elif code[0] == LOAD:
 return eval_load(continuation, context, code)
 else:
 return eval_apply(continuation, context, code)
 elif isinstance(code, symbol):
 return (continuation, context.get(str(code)))
 else:
 return (continuation, code)

#Helper to evaluate a list of expressions
class expr_list_continuation:
 def __init__(self, continuation, context, exprs):
 expr, rest = exprs
 self.expr = expr
 if rest == None:
 self.continuation = continuation
 else:
 self.continuation = expr_list_continuation(continuation,
 context, rest)
 self.context = context

 def run(self, value):
 return eval(self.continuation, self.context, self.expr)

def eval_expr_list(continuation, context, exprs):
 return (expr_list_continuation(continuation, context, exprs), None)


#Quote
def eval_quote(continuation, context, code):
 (quote, (item, nil)) = code
 return (continuation, item)

#Load
def eval_load(continuation, context, code):
 (load, (filepath, nil)) = code
 fi = file(filepath)
 exprs = sexprs(fi.read())
 return eval_expr_list(continuation, context, exprs)

#Begin
def eval_begin(continuation, context, code):
 begin, exprs = code
 return eval_expr_list(continuation, context, exprs)

#Lambda
def eval_lambda(continuation, parent_context, code):
 (lmbda, (params, exprs)) = code
 def func(continuation, args):
 new_context = context(parent_context, params, args)
 return eval_expr_list(continuation, new_context, exprs)
 return (continuation, func)

#Define
class define_continuation:
 def __init__(self, continuation, context, var_name):
 self.continuation = continuation
 self.context = context
 self.var_name = var_name

 def run(self, value):
 self.context.define(self.var_name, value)
 return self.continuation, None

def eval_define(continuation, context, code):
 (define, (var_name, (expr, nil))) = code
 continuation = define_continuation(continuation,
 context, str(var_name))
 return eval(continuation, context, expr)

#set!
class set_continuation:
 def __init__(self, continuation, context, var_name):
 self.continuation = continuation
 self.context = context
 self.var_name = var_name

 def run(self, value):
 self.context.set(self.var_name, value)
 return self.continuation, None

def eval_set(continuation, context, code):
 (set, (var_name, (expr, nil))) = code
 continuation = set_continuation(continuation, context,
 str(var_name))
 return eval(continuation, context, expr)

#If
class if_continuation:
 def __init__(self, continuation, context, ifTrue, ifFalse):
 self.continuation = continuation
 self.context = context
 self.ifTrue = ifTrue
 self.ifFalse = ifFalse

 def run(self, value):
 if value:
 return eval(self.continuation,
 self.context, self.ifTrue)
 else:
 return eval(self.continuation,
 self.context, self.ifFalse)

def eval_if(continuation, context, code):
 (If, (predicate, (ifTrue, rest))) = code
 if rest==None:
 ifFalse = None
 else:
 ifFalse = rest[0]
 return eval(if_continuation(continuation, context, ifTrue, ifFalse),
 context, predicate)

#Apply

class apply_continuation:
 def __init__(self, continuation):
 self.continuation = continuation

 def run(self, func):
 return func(self.continuation, self.params)

class param_continuation:
 def __init__(self, continuation, prev):
 self.continuation = continuation
 self.prev = prev
 self.params = None

 def run(self, value):
 self.prev.params = (value, self.params)
 return (self.continuation, None)

class list_param_continuation:
 def __init__(self, continuation, prev):
 self.continuation = continuation
 self.prev = prev
 def run(self, value):
 self.prev.params = value
 return (self.continuation, None)

def construct_param_continuations(continuation,
 prev, context, code):
 if isinstance(code, list):
 expr, rest = code
 paramContinuation = param_continuation(continuation, prev)
 continuation = eval_continuation(paramContinuation, context, expr)
 if rest == None:
 return continuation
 else:
 return construct_param_continuations(continuation, paramContinuation,
 context, rest)
 else:
 continuation = list_param_continuation(continuation, prev)
 return eval_continuation(continuation, context, code)



def eval_apply(continuation, context, code):
 (operator, exprs) = code
 apply_cont = apply_continuation(continuation)
 continuation = eval_continuation(apply_cont, context, operator)
 continuation = construct_param_continuations(continuation, apply_cont,
 context, exprs)
 return (continuation, None)

#The read eval loop

class read_eval_continuation:
 def __init__(self, context, reader):
 self.context = context
 self.reader = reader
 self.code = None
 self.continuation = None

 def run(self, value):
 try:
 if self.code == None:
 self.code = self.reader.next()
 self.continuation = read_eval_continuation(self.context,
 self.reader)
 except StopIteration:
 return None, value
 return eval_str(self.continuation, self.context, self.code)


def expression_reader(fi):
 code = ""
 brackets = 0
 while True:
 if code == "":
 prompt = ">>>"
 else:
 prompt = "..."
 ln = raw_input(prompt)
 code+=ln+" "
 brackets+=ln.count("(") - ln.count(")")
 if brackets == 0 and len(ln.strip())!=0:
 yield code
 code = ""

def read_eval_loop(fi):
 reader = expression_reader(fi)
 continuation = read_eval_continuation(global_context, reader)
 value = "Simple scheme!!!"
 while(continuation!=None):
 (continuation, value) = continuation.run(value)

if __name__=="__main__":
 import sys
 read_eval_loop(sys.stdin)

A simple backup script

2004-09-09T05:07:00.000-07:00

#backup.py
#
#backupdirs  - a list of complete paths of directories to backup
#excludes    - a list of subdirectories to be excluded
#backupdir   - the path to the directory where the backup should be written
#machinename - the name of the machine

backupdirs = []
excludes = []
backupdir = "."
machinename = "the_box"

from zipfile import ZipFile
import time

try:
    from itertools import chain
except:
    def chain(*iterators):
        for i in iterators:
            for j in i:
                yield j

def getAllFilesInPath(path):
    from os import listdir
    from os.path import isdir, join
    dirs = chain(*[getAllFilesInPath(join(path, filename))
           for filename in listdir(path)
           if isdir(join(path, filename)) and join(path, filename) not in excludes])
    files = [join(path,filename)
           for filename in listdir(path)
           if not isdir(join(path, filename))]
    return chain(files, dirs)


def backup():
    from os.path import join
    zf = ZipFile(time.strftime(join(backupdir,machinename+"%-d-%m-%Y.zip")),"w")
    for backupdir in backupdirs:
        for filename in getAllFilesInPath(backupdir):
            zf.write(filename)
    zf.close()

if __name__ == "__main__":
    backup()

Resizing images in python

2004-09-06T04:04:00.000-07:00

# resize.py
# Simply put the file into the directory of images
# and run.
#
# A directory called resized is created, into which
# the resized images are put
#
# resizeFactor of 0.5 redueces the height and width
# by half

import Image
import glob
import os
from os.path import join

resizeFactor = 0.5

if not os.path.isdir("resized"):
    os.mkdir("resized")

for i in glob.glob("*.jpg"):
    im = Image.open(i)
    width, height = im.size
    print join("resized", i)
    im.resize((int(width*resizeFactor),
              int(height*resizeFactor))).save(join(os.curdir, "resized", i))

Usefull python libraries

2004-08-12T02:06:00.000-07:00

These are libraries I find myself using quite often. I install them whenever i do a new install of python

wxPython

http://www.wxpython.org

A python wrapper for the wxWidgets library. wxPython is nice, easy to use and fast.

Numerical Python(numeric):

http://www.pfdubois.com/numpy/

An array library, it is good if you are doing repetitive calculations on large
amounts of data or doing matrix operations.

Python Imaging Library (PIL):

http://www.pythonware.com/products/pil/

Basic image processing.

Python Extentions for Windows(win32all):

http://starship.python.net/crew/mhammond/

Comes with a decent ide 'pythonwin' and support for com and mfc. Its a must have on windows.

The ReportLab Toolkit:

http://www.reportlab.org/downloads.html

For generating pdf documents

A simple python colorizer

2004-08-11T03:15:00.000-07:00

#This blog is all about python and python code.
#
#I realize that ill be putting up a lot of code so I've
#written this simple python code to html converter.

#pyhtmlizer.py
#Colorize and convert you py file into html
#Usage: python pyhtmlizer <filename>
#Fixes:
#24-Feb-2005: Added elif and class to the keywords list
#24-Feb-2005: Function names in def starting with
# underscores get coloured correctly
#26-Mar-2005: Fixed the regular expression to handle
# the '\' in strings properly.
#31-Mar-2005:Added print to the keywords list

import re

keyWords= ["def", "import", "from", "for", "if", "else",
 "elif", "in", "and", "or", "not", "while", "print",
 "return", "yield", "try", "except", "class"]

r = re.compile("[a-zA-Z\_][\\w]*|"+
 "\t|"+"\n|"+
 "\d[\\.\\w]*|"+
 "\"\"\"(?:(?:\\\\.|[^\"])*)\"\"\"|"+
 "\"(?:(?:\\\\.|[^\"])*)\"|"+
 "\'\'\'(?:(?:\\\\.|[^\'])*)\'\'\'|"+
 "\'(?:(?:\\\\.|[^\'])*)\'|"+
 "#[^\\n]*\\n|"
 ".",
 re.DOTALL)

replaceList = [("&", "&"),
 (" ", " "),
 ("\t", " "*4),
 ("<", "<"),
 (">", ">"),
 ("\n", " ")]

replaceDict = dict(replaceList)
markupdict = {
 "keyword":'%s',
 "def":'%s',
 "number":'%s',
 "string":'%s',
 "comment":'%s'}

def colorize(code, type):
 return markupdict[type] % code

def htmlizedTokens(code):
 indef = False
 for token in r.findall(code):
 if token in keyWords:
 if token in ["class", "def"]:
 indef = True
 yield colorize(token, "keyword")
 elif token[0].isdigit():
 yield colorize(token, "number")
 elif token[0].isalpha() or token[0]=="_":
 if indef:
 indef = False
 yield colorize(token, "def")
 else:
 yield token
 elif replaceDict.has_key(token):
 yield replaceDict[token]
 elif token[0] == "#":
 yield colorize(reduce(lambda s, (old, new):
 s.replace(old, new), replaceList, token),
 "comment")
 elif token[0] in ["'", '"']:
 yield colorize(reduce(lambda s, (old, new):
 s.replace(old, new), replaceList, token),
 "string")
 else:
 yield token

def htmlize(code):
 return "".join(htmlizedTokens(code))

if __name__ == "__main__":
 import sys
 if len(sys.argv):
 fi = file(sys.argv[1])
 fo = file(sys.argv[1]+".html", "w")
 fo.write(htmlize(fi.read()))
 fi.close()
 fo.close()