I’m not sure whether the first story here is meant to encourage or dissuade, but I am writing my own WSGI framework to support Burble. Colubrid is holding me back, and its replacement Werkzeug is overkill for what I want. (To be fair, Colubrid has been a great help to me in getting started.) I’m really getting into the educational aspect of doing things from scratch where I can.

It turns out that putting together a very lightweight WSGI framework is very easy indeed, especially having made a small compromise by using a few pre-built things from Ian Bicking’s Paste. (Yeah, I contradict myself. I am large, I contain multitudes.)

It’s so easy that I’m almost done, so I present a tiny, noddy framework for your reading pleasure. It implements a regex-based URL dispatcher a la Web.py.

#!/usr/bin/python
from paste.request import parse_formvars
from paste.response import HeaderDict
import re

def attrsfromdict(d):
    """From Python cookbook s6.18 p 280"""
    self = d.pop('self')
    for n,v in d.iteritems():
        setattr(self, n, v)
        
def simplerepr(obj):
	d = obj.__dict__
	members = ', '.join([n + '=' + v.__repr__() for n,v in d.iteritems()])
	return '%s(%s)' % (obj.__class__.__name__, members)

class NoMatchingControllerException(Exception):
    pass
    
class Request(object):
    def __init__(self, environ):
        self.environ = environ
        self.fields = parse_formvars(environ)
        
class Response(object):
    def __init__(self,
        status_code='200',
        response_phrase="OK", body="",
        headers=HeaderDict({'content-type': 'text/html'})
        ):
        attrsfromdict(locals())
    def __str__(self):
        return simplerepr(self)
    def __repr__(self):
        return self.__str__()
    def status(self):
        return ' '.join([self.status_code, self.response_phrase])
                
class Dispatcher(object):
    """
    The Dispatcher maintains an internal list of regexes and controllers.
    The Dispatcher accepts strings, and tries to match in turn against
    the regexes. As soon as a match is found, the corresponding controller is
    invoked.
    """
    def __init__(self, regex_app_tuples):
        self.dispatch_list = []
        for k, v in regex_app_tuples:
            p = re.compile(k)
            self.dispatch_list.append((p, v))
            
    def dispatch(self, request):
        """
        Expects to call a Controller's instance method GET or POST
        with the request and the groups obtained from the regex
        as arguments.
        """    
        path_info = request.environ.get('PATH_INFO', '')
        method = request.environ['REQUEST_METHOD']
        
        for pat, app in self.dispatch_list:
            mo = pat.match(path_info)
            if mo != None:
                args = [request]

                args.extend([i for i in mo.groups()])
                if method == 'GET':
                    return app.GET(*args)    
                elif method =='POST':
                    return app.POST(*args)                    
        raise NoMatchingControllerException, "No match for %s" % path_info

class WhiskyApp(object):
    def __init__(self, dispatcher):
        self.dispatcher = dispatcher
    def __call__(self, environ, start_response):        
        request = Request(environ)
        response = self.dispatcher.dispatch(request)
        start_response(response.status(), response.headers.items())
        return [response.body]
        
class NoddyController(object):
    def GET(self, request, id):
        r = Response(body="Noddy got %s" % id)
        return r
        
class BigEarsController(object):
    def __init__(self):
        print "in init"
    def GET(self, request, arg1, arg2):
        r = Response(body="Big Ears got %s and %s" % (arg1, arg2))
        return r        

if __name__ == '__main__':
    from paste import httpserver
    dispatch_list = [
                    (r'/noddy/(\d+)/?$', NoddyController()),
                    (r'/bigears/(.*?)/(\d+)/?$', BigEarsController())
                    ]
    dispatcher = Dispatcher(dispatch_list)
    app = WhiskyApp(dispatcher)
    httpserver.serve(app, host='127.0.0.1', port='8080')

That’s pretty much all I need, to be honest. I’m happy using Beaker for sessions, and I’ll probably pull in cookie stuff from Paste. I bodged up an Etag cache manager for Burble, which I want to integrate. I want to write a nice base class for controllers. And that’s it. Whee!