OF COURSE when I saw that someone on the Interwebz managed to get the new Google Maps with navigation running on a G1, I almost wet myself with excitement. Normally this app only runs on the new Android 2.0 phones (namely, Droid from Verizon) and even rooted G1 are still only running Android 1.6. The instructions call for basically replacing the entire build properties on your phone with the Droid ones.

I’m not going to write any explicit instructions, since those are already on the forums and easily accessible with a Google search. But here’s basically what I did, which temporarily enabled navigation. To build.prop, I made the following changes:

kkinder@kkinder-laptop ~/Desktop> diff -u bp2 build.prop
--- build.prop.org	2009-11-16 11:40:34.000000000 -0700
+++ build.prop	2009-11-10 19:13:18.000000000 -0700
@@ -1,6 +1,6 @@
 # begin build properties
-ro.build.version.sdk=4
-ro.build.version.release=1.6
+ro.build.version.sdk=<strong>5</strong>
+ro.build.version.release=<strong>2.0</strong>
 ro.build.version.codename=REL
 ro.build.type=user
 ro.build.user=shade
@@ -15,7 +15,7 @@
 ro.com.android.wifi-watchlist=GoogleGuest
 ro.com.android.dateformat=MM-dd-yyyy
 ro.com.android.dataroaming=true
-ro.com.google.clientidbase=android-tmobile
+ro.com.google.clientidbase=<strong>android-verizon</strong>
 ro.setupwizard.mode=OPTIONAL
 ro.url.legal=http://www.google.com/intl/%s/mobile/android/android-dev-phone-legal.html
 ro.url.legal.android_privacy=http://www.google.com/intl/%s/mobile/android/android-dev-phone-privacy.html

At this point, after using the unix find command in my phone’s terminal emulator to delete old maps data files and application files, I was able to reboot and install the maps app with all its new features — all its new features, except for navigation. So, I continued with the *real* instructions and applied changes to build.trout.prop

--- build.trout.prop.orig	2009-11-16 11:40:56.000000000 -0700
+++ build.trout.prop	2009-11-10 19:13:18.000000000 -0700
@@ -1,25 +1,25 @@
 # begin build properties
 # autogenerated by buildinfo.sh
-ro.build.id=DRC83
-ro.build.display.id=DRC83
-ro.build.version.incremental=14721
+ro.build.id=ESD20
+ro.build.display.id=ESD20
+ro.build.version.incremental=17572
 ro.build.date=Mon Sep 21 16:16:12 PDT 2009
 ro.build.date.utc=1253574972
-ro.product.model=T-Mobile G1
-ro.product.brand=tmobile
+ro.product.model=Droid
+ro.product.brand=verizon
 ro.product.name=kila
-ro.product.device=dream
-ro.product.board=trout
+ro.product.device=sholes
+ro.product.board=sholes
 ro.product.cpu.abi=armeabi
-ro.product.manufacturer=HTC
+ro.product.manufacturer=Motorola
 ro.product.locale.language=en
 ro.product.locale.region=US
 ro.board.platform=msm7k
 # ro.build.product is obsolete; use ro.product.device
 ro.build.product=dream
 # Do not try to parse ro.build.description or .fingerprint
-ro.build.description=kila-user 1.6 DRC83 14721 ota-rel-keys,release-keys
-ro.build.fingerprint=tmobile/kila/dream/trout:1.6/DRC83/14721:user/ota-rel-keys,release-keys
+ro.build.description=voles-user 2.0 ESD20 17572 ota-rel-keys,release-keys
+ro.build.fingerprint=verizon/voles/sholes/sholes:2.0/ESD20/17572:user/ota-rel-keys,release-keys
 # end build properties
 #
 # system.prop for dream

I don’t really like the idea of editing these files, because when the system lies about its version numbers, it could break other apps. But I made backups and did it anyway, with no dice on having a working navigation system. Some reading on a thread that grew to 50 posts within hours and I noticed some users reported that uninstalling and reinstalling Google Voice got navigation working on the (presumably unrelated) maps app, which it did.

But here’s the frustrating part: After driving around and enjoying your new navigation system, you go to restore your build*props files. If you revert version numbers, the app continues to work. However once you change your phone’s model information back (ie, you switch Verizon back to T-Mobile), your navigation disappears in the GUI. In other words, the map app is checking to make sure you’re running on Verizon’s network, and only allows you navigation then. That’s kind of slimey, but update: the updated Android 1.6 app includes navigation, so I guess my initial conspiracy theories are irrelevant.

That happens because NiftyCube has code to correct rendering problems in previous version of IE. Since IE 8 renders more elements correctly, NiftyCube’s hack actually makes things worse in IE 8. To fix the problem, disable their fix for IE 8. Apply this change to niftycube.js:

Index: tuber/trunk/common/web/htdocs/assets/js/niftycube.js
===================================================================
--- a/tuber/trunk/common/web/htdocs/assets/js/niftycube.js
+++ b/tuber/trunk/common/web/htdocs/assets/js/niftycube.js
@@ -156,7 +156,22 @@
 }
 
+function getIeVersion() {
+    var rv = -1;
+    if (navigator.appName == 'Microsoft Internet Explorer') {
+        var ua = navigator.userAgent;
+        var re = new RegExp("MSIE ([0-9]{1,}[\.0-9]{0,})");
+        if (re.exec(ua) != null) {
+            rv = parseFloat(RegExp.$1);
+        }
+    }
+    return rv;
+}
+
 function FixIE(el){
 if(el.currentStyle!=null && el.currentStyle.hasLayout!=null && el.currentStyle.hasLayout==false)
-    el.style.display="inline-block";
+    var ver = getIeVersion();
+    if (ver < 8) {
+        el.style.display="inline-block";
+    }
 }

If you visit the URI /foo/bar/spam, CherryPy looks for a foo.bar controller with a spam action (sort of). There are other mostly irrelevant complexities (mount points for quasi-apps and such), but that’s the gist. You can write your own “dispatcher” in CherryPy to map URLs to executable code, or use ones such as the RoutesDispatcher, which uses Groovie Routes to map URLs to code. But using your own component is always kind of a sour-tasting afterthought in CherryPy and you’re sometimes reminded of that, unpleasantly (for example, routes for static content do not work in RoutesDispatcher).

In version 3, CherryPy’s previously simple configuration system got kind of confusing. I started writing a lot of code like this:

cherrypy.config.update(myConfig)
app = cherrypy.tree.mount(None, moreConfig)
cherrypy.config.update(someFile)
cherrypy.quickstart(app)

CherryPy lets you pass in configuration options a number of ways: In Python: dicts passed to config.update, dicts passed to tree.mount, or dicts on your controller object. In ConfigParser syntax: as filenames passed to config.update or tree.mount. The problem is that I’m always left with trial-and-error in figuring out what options I have; configuration directives don’t work everywhere, and you’re given relatively little guidance finding out where. If the documentation were better, that might help, but it’s confusing no matter what.

Which brings me to my most significant grievance with CherryPy: Its documentation is mediocre and because it takes such a novel approach to so many things, it needs good documentation. Most of CherryPy’s documentation is on a loosely organized wiki that resembles someone’s lecture notes more than it resembles documentation. This makes finding specific pieces of information difficult; for example, the RoutesDispatcher from above is buried deep down on a page called “PageHandlers” and is otherwise mostly unmentioned. Sometimes the wiki looks helpful, such as on this file upload page, but in practice the examples given are apparently built for an old version of the framework (“from cherrypy.lib.filter import basefilter” results in an ImportError).

You can always ask CherryPy’s mailing list, but be forewarned: it’s not very inhabited now that TurboGears moved to Pylons.

Where is CherryPy superior?

After all these gripes, you might think I’m fully convinced that move to Pylons is good. A simple “Hello World” comparison reveals why that’s not the case. In CherryPy:

import cherrypy
 
class HelloWorld(object):
    def index(self):
        return "Hello World!"
    index.exposed = True
 
cherrypy.quickstart(HelloWorld())

In Pylons: … this is going to take some time. Pylons doesn’t let you create a Hello World app in one file. Or even one directory. You start by running this command (for convenience and comic effect, there are scroll bars):

kkinder@kkinder-laptop ~> paster create MyHelloWorldProject -t pylons
Selected and implied templates:
  Pylons#pylons  Pylons application template

Variables:
  egg:      MyHelloWorldProject
  package:  myhelloworldproject
  project:  MyHelloWorldProject
Enter template_engine (mako/genshi/jinja2/etc: Template language) ['mako']:
Enter sqlalchemy (True/False: Include SQLAlchemy 0.5 configuration) [False]:
Creating template pylons
Creating directory ./MyHelloWorldProject
  Recursing into +package+
    Creating ./MyHelloWorldProject/myhelloworldproject/
    Copying templates/default_project/+package+/__init__.py_tmpl to ./MyHelloWorldProject/myhelloworldproject/__init__.py
    Recursing into config
      Creating ./MyHelloWorldProject/myhelloworldproject/config/
      Copying templates/default_project/+package+/config/__init__.py_tmpl to ./MyHelloWorldProject/myhelloworldproject/config/__init__.py
      Copying templates/default_project/+package+/config/deployment.ini_tmpl_tmpl to ./MyHelloWorldProject/myhelloworldproject/config/deployment.ini_tmpl
      Copying templates/default_project/+package+/config/environment.py_tmpl to ./MyHelloWorldProject/myhelloworldproject/config/environment.py
      Copying templates/default_project/+package+/config/middleware.py_tmpl to ./MyHelloWorldProject/myhelloworldproject/config/middleware.py
      Copying templates/default_project/+package+/config/routing.py_tmpl to ./MyHelloWorldProject/myhelloworldproject/config/routing.py
    Recursing into controllers
      Creating ./MyHelloWorldProject/myhelloworldproject/controllers/
      Copying templates/default_project/+package+/controllers/__init__.py_tmpl to ./MyHelloWorldProject/myhelloworldproject/controllers/__init__.py
      Copying templates/default_project/+package+/controllers/error.py_tmpl to ./MyHelloWorldProject/myhelloworldproject/controllers/error.py
    Recursing into lib
      Creating ./MyHelloWorldProject/myhelloworldproject/lib/
      Copying templates/default_project/+package+/lib/__init__.py_tmpl to ./MyHelloWorldProject/myhelloworldproject/lib/__init__.py
      Copying templates/default_project/+package+/lib/app_globals.py_tmpl to ./MyHelloWorldProject/myhelloworldproject/lib/app_globals.py
      Copying templates/default_project/+package+/lib/base.py_tmpl to ./MyHelloWorldProject/myhelloworldproject/lib/base.py
      Copying templates/default_project/+package+/lib/helpers.py_tmpl to ./MyHelloWorldProject/myhelloworldproject/lib/helpers.py
    Recursing into model
      Creating ./MyHelloWorldProject/myhelloworldproject/model/
      Copying templates/default_project/+package+/model/__init__.py_tmpl to ./MyHelloWorldProject/myhelloworldproject/model/__init__.py
    Recursing into public
      Creating ./MyHelloWorldProject/myhelloworldproject/public/
      Copying templates/default_project/+package+/public/bg.png to ./MyHelloWorldProject/myhelloworldproject/public/bg.png
      Copying templates/default_project/+package+/public/favicon.ico to ./MyHelloWorldProject/myhelloworldproject/public/favicon.ico
      Copying templates/default_project/+package+/public/index.html_tmpl to ./MyHelloWorldProject/myhelloworldproject/public/index.html
      Copying templates/default_project/+package+/public/pylons-logo.gif to ./MyHelloWorldProject/myhelloworldproject/public/pylons-logo.gif
    Recursing into templates
      Creating ./MyHelloWorldProject/myhelloworldproject/templates/
    Recursing into tests
      Creating ./MyHelloWorldProject/myhelloworldproject/tests/
      Copying templates/default_project/+package+/tests/__init__.py_tmpl to ./MyHelloWorldProject/myhelloworldproject/tests/__init__.py
      Recursing into functional
        Creating ./MyHelloWorldProject/myhelloworldproject/tests/functional/
        Copying templates/default_project/+package+/tests/functional/__init__.py_tmpl to ./MyHelloWorldProject/myhelloworldproject/tests/functional/__init__.py
      Copying templates/default_project/+package+/tests/test_models.py_tmpl to ./MyHelloWorldProject/myhelloworldproject/tests/test_models.py
    Copying templates/default_project/+package+/websetup.py_tmpl to ./MyHelloWorldProject/myhelloworldproject/websetup.py
  Copying templates/default_project/MANIFEST.in_tmpl to ./MyHelloWorldProject/MANIFEST.in
  Copying templates/default_project/README.txt_tmpl to ./MyHelloWorldProject/README.txt
  Copying templates/default_project/development.ini_tmpl to ./MyHelloWorldProject/development.ini
  Recursing into docs
    Creating ./MyHelloWorldProject/docs/
    Copying templates/default_project/docs/index.txt_tmpl to ./MyHelloWorldProject/docs/index.txt
  Copying templates/default_project/ez_setup.py to ./MyHelloWorldProject/ez_setup.py
  Copying templates/default_project/setup.cfg_tmpl to ./MyHelloWorldProject/setup.cfg
  Copying templates/default_project/setup.py_tmpl to ./MyHelloWorldProject/setup.py
  Copying templates/default_project/test.ini_tmpl to ./MyHelloWorldProject/test.ini
Running /usr/bin/python setup.py egg_info

I of course went for the lighter option that doesn’t include SQLAlchemy. Okay, we’re almost there. Now I’m going to create a Hello controller:

kkinder@kkinder-laptop ~/MyHelloWorldProject> paster controller Hello
Creating /home/kkinder/MyHelloWorldProject/myhelloworldproject/controllers/Hello.py
Creating /home/kkinder/MyHelloWorldProject/myhelloworldproject/tests/functional/test_Hello.py

This is where Pylons READS MY MIND and does the work for me. Take a look at the new Hello.py controller it made for me:

import logging
 
from pylons import request, response, session, tmpl_context as c
from pylons.controllers.util import abort, redirect_to
 
from myhelloworldproject.lib.base import BaseController, render
 
log = logging.getLogger(__name__)
 
class HelloController(BaseController):
 
    def index(self):
        # Return a rendered template
        #return render('/Hello.mako')
        # or, return a response
        return 'Hello World'

But I’m not done yet. Now I need to edit my routing.py file, check my development.ini for any settings, run “setup.py develop” and then use “paster serve” to finally test my app. By the time I’m done printing “Hello World”, I have 42 files in 11 directories:

.
|-- MANIFEST.in
|-- MyHelloWorldProject.egg-info
|   |-- PKG-INFO
|   |-- SOURCES.txt
|   |-- dependency_links.txt
|   |-- entry_points.txt
|   |-- not-zip-safe
|   |-- paster_plugins.txt
|   |-- requires.txt
|   `-- top_level.txt
|-- README.txt
|-- development.ini
|-- docs
|   `-- index.txt
|-- ez_setup.py
|-- myhelloworldproject
|   |-- __init__.py
|   |-- __init__.pyc
|   |-- config
|   |   |-- __init__.py
|   |   |-- deployment.ini_tmpl
|   |   |-- environment.py
|   |   |-- middleware.py
|   |   `-- routing.py
|   |-- controllers
|   |   |-- Hello.py
|   |   |-- __init__.py
|   |   `-- error.py
|   |-- lib
|   |   |-- __init__.py
|   |   |-- __init__.pyc
|   |   |-- app_globals.py
|   |   |-- base.py
|   |   |-- base.pyc
|   |   `-- helpers.py
|   |-- model
|   |   `-- __init__.py
|   |-- public
|   |   |-- bg.png
|   |   |-- favicon.ico
|   |   |-- index.html
|   |   `-- pylons-logo.gif
|   |-- templates
|   |-- tests
|   |   |-- __init__.py
|   |   |-- functional
|   |   |   |-- __init__.py
|   |   |   `-- test_Hello.py
|   |   `-- test_models.py
|   `-- websetup.py
|-- setup.cfg
|-- setup.py
`-- test.ini

11 directories, 42 files

The Django/Pylons/TurboGears frameworks all follow a teeth gnashing design pattern that came out of Java and was made ugly in Ruby: Code generation. This is just my opinion, but in a language as dynamic and meta-programmative as Python, code generation is obsolete at best. What happens when the basic layout for a project changes a bit in the next version of Pylons? Do I “diff” the paste template and compare it to the old version to see what changed? And half of the configuration is in Pylon’s WSGI-obsessed middleware.py file, which is itself both a product of code generation and subsequent edits by the developer:

"""Pylons middleware initialization"""
from beaker.middleware import CacheMiddleware, SessionMiddleware
from paste.cascade import Cascade
from paste.registry import RegistryManager
from paste.urlparser import StaticURLParser
from paste.deploy.converters import asbool
from pylons import config
from pylons.middleware import ErrorHandler, StatusCodeRedirect
from pylons.wsgiapp import PylonsApp
from routes.middleware import RoutesMiddleware
 
from myhelloworldproject.config.environment import load_environment
 
def make_app(global_conf, full_stack=True, static_files=True, **app_conf):
    """Create a Pylons WSGI application and return it
 
    ``global_conf``
        The inherited configuration for this application. Normally from
        the [DEFAULT] section of the Paste ini file.
 
    ``full_stack``
        Whether this application provides a full WSGI stack (by default,
        meaning it handles its own exceptions and errors). Disable
        full_stack when this application is "managed" by another WSGI
        middleware.
 
    ``static_files``
        Whether this application serves its own static files; disable
        when another web server is responsible for serving them.
 
    ``app_conf``
        The application's local configuration. Normally specified in
        the [app:<name>] section of the Paste ini file (where <name>
        defaults to main).
 
    """
    # Configure the Pylons environment
    load_environment(global_conf, app_conf)
 
    # The Pylons WSGI app
    app = PylonsApp()
 
    # Routing/Session/Cache Middleware
    app = RoutesMiddleware(app, config['routes.map'])
    app = SessionMiddleware(app, config)
    app = CacheMiddleware(app, config)
 
    # CUSTOM MIDDLEWARE HERE (filtered by error handling middlewares)
 
    if asbool(full_stack):
        # Handle Python exceptions
        app = ErrorHandler(app, global_conf, **config['pylons.errorware'])
 
        # Display error documents for 401, 403, 404 status codes (and
        # 500 when debug is disabled)
        if asbool(config['debug']):
            app = StatusCodeRedirect(app)
        else:
            app = StatusCodeRedirect(app, [400, 401, 403, 404, 500])
 
    # Establish the Registry for this application
    app = RegistryManager(app)
 
    if asbool(static_files):
        # Serve static files
        static_app = StaticURLParser(config['pylons.paths']['static_files'])
        app = Cascade([static_app, app])
 
    return app

Beyond its sanity in not generating piles of code, CherryPy has other advantages. Its testing framework is very easy to use, but and also documented with almost no examples. Pylons, in contrast, tells you where to put the tests but doesn’t make it quite as easy to run them.

On a day to day basis, writing code in CherryPy is seldom a chore; it isn’t exciting or cutting edge, but it’s simple and usually CherryPy does a good job of staying out of your way. I’m never left wondering in CherryPy whether there is a specific “CherryPy way to do it,” while in Pylons, my framework even has an opinion on what Javascript library I choose (it likes script.aculo.us, although it doesn’t bang you over the head with it). CherryPy is usually simpler: take a look at repoze.who/what or AuthKit in the Pylons world and compare a very simple CherryPy auth example.

But there are places where Pylons is amazing…

One more thing: What’s missing from CherryPy?

Pylons error handling is the one killer feature it has that CherryPy just lacks. Skip to line 598 of the “Hello, World” pylons project and try throwing an error:

    def index(self):
        raise ValueError

Then use the controller. In CherryPy, I would get a Python traceback wrapped in a <pre> tag. In Pylons, I get an ajax debugger with expression evaluation and variable inspection:

I can inspect variables and evaluate expressions at each point in the traceback:

Along with view environment info, complete source code of running file and template, and more.

Wrapping it up

I normally would have a strong aversion to “glue” frameworks that try (usually badly) to integrate unrelated toolsets. Having said that, when I sit down and build my own framework in CherryPy, I want to use SQLAlchemy, Groovie Routes, and Mako templates. (Pylons’ “webhelpers” are nice too.)

Pylons offers all those those tools in a bundle. Also, its mailing list is far more active. While CherryPy manages a post or two a day, Pylons has a high quality post every hour or more. I’m not saying I’m giving up on CherryPy, but if I started a project today, I would seriously consider Pylons as a more friendly alternative, even if it relies on code generation.

meld spam.orig spam.mine - eggs.orig eggs.mine - pants.orig pants.mine

The usage is the same as it was before, but now you can specify multiple comparisons, separated by “-”. We’ll see if the patch is accepted; I posted it to the mailing list. In the meantime, you can download it here.

"""
Example code using mysqlsession.py
"""
from mysqlsession import MySQLSession
import cherrypy
import logging
 
logging.basicConfig(level=logging.DEBUG)
 
sessionInfo = {
    'tools.sessions.on': True,
    'tools.sessions.storage_type': "Mysql",
    'tools.sessions.connect_arguments': {'db': 'sessions'},
    'tools.sessions.table_name': 'session'
}
 
cherrypy.config.update(sessionInfo)
 
class HelloWorld:
    def index(self):
        v = cherrypy.session.get('v', 1)
        cherrypy.session['v'] = v+1
        return "Hello world! %s" % v
 
    index.exposed = True
 
cherrypy.quickstart(HelloWorld())

Download the module: mysqlsession.py

I would publish it formally, but I’m going to see if I can just have it added to the CherryPy project.

UPDATE: I took out the table locking and used InnoDB select-for-update locking.

--- httplib.py.orig	2008-12-16 19:14:07.000000000 -0600
+++ httplib.py	2008-12-16 19:26:20.000000000 -0600
@@ -69,6 +69,7 @@
 import errno
 import mimetools
 import socket
+import logging
 from urlparse import urlsplit
 
 try:
@@ -342,7 +343,7 @@
         # Initialize with Simple-Response defaults
         line = self.fp.readline()
         if self.debuglevel > 0:
-            print "reply:", repr(line)
+            logging.info("reply: %r" % (line,))
         if not line:
             # Presumably, the server closed the connection before
             # sending a valid response.
@@ -391,7 +392,7 @@
                 if not skip:
                     break
                 if self.debuglevel > 0:
-                    print "header:", skip
+                    logging.info('header: %r' % (skip,))
 
         self.status = status
         self.reason = reason.strip()
@@ -414,7 +415,7 @@
         self.msg = HTTPMessage(self.fp, 0)
         if self.debuglevel > 0:
             for hdr in self.msg.headers:
-                print "header:", hdr,
+                logging.info('header: %r' % (hdr,))
 
         # don't let the msg keep an fp
         self.msg.fp = None
@@ -665,11 +666,11 @@
             try:
                 self.sock = socket.socket(af, socktype, proto)
                 if self.debuglevel > 0:
-                    print "connect: (%s, %s)" % (self.host, self.port)
+                    logging.info("connect: (%s, %s)" % (self.host, self.port))
                 self.sock.connect(sa)
             except socket.error, msg:
                 if self.debuglevel > 0:
-                    print 'connect fail:', (self.host, self.port)
+                    logging.info('connect fail:', (self.host, self.port))
                 if self.sock:
                     self.sock.close()
                 self.sock = None
@@ -702,7 +703,7 @@
         # NOTE: we DO propagate the error, though, because we cannot simply
         #       ignore the error... the caller will know if they can retry.
         if self.debuglevel > 0:
-            print "send:", repr(str)
+            logging.info("send: %s" % (str,))
         try:
             self.sock.sendall(str)
         except socket.error, v:

httplib-logging-patch

while True:
    try:
        lockfd = os.open(path, os.O_CREAT|os.O_WRONLY|os.O_EXCL)
    except OSError:
        time.sleep(0.1)
    else:
        os.close(lockfd)
        break
self.locked = True

Really people, really? We silently loop until an error goes away? Really?

Python decorators are a way of modifying a function, of quickly wrapping it. They’re sort of like aspect-oriented programming, in that they let you define logic that cross-cuts methods all over your program. Here’s an example that takes a method that returns a list, and converts that list to a CSV file.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import csv
import StringIO
 
def list2csv(func):
    def wrapper(*args, **kwargs):
        listValue = func(*args, **kwargs)
        fd = StringIO.StringIO()
        writer = csv.writer(fd)
        for row in listValue:
            writer.writerow(row)
        return fd.getvalue()
    return wrapper
 
@list2csv
def getList():
    return [
        ('First Name', 'Last Name',  'Profession'),
        ('Ken',        'Kinder',     'Software Engineer'),
        ('John',       'Stewart',    'Funny man'),
        ('Guido',      'Van Russum', 'Smart guy')
        ]
 
print getList()

Results in…

First Name,Last Name,Profession
Ken,Kinder,Software Engineer
John,Stewart,Funny man
Guido,Van Russum,Smart guy

Now, you may have seen a few decorators that take keyword arguments, and look like this:

1
2
3
4
5
6
7
8

@list2csv(dialect=csv.exel)
def getList():
    return [
        ('First Name', 'Last Name',  'Profession'),
        ('Ken',        'Kinder',     'Software Engineer'),
        ('John',       'Stewart',    'Funny man'),
        ('Guido',      'Van Russum', 'Smart guy')
        ]

If you’re like me, you’re tempted to just add a keyword argument, dialect, to the list2csv method. But what’s important to keep in mind is that the text after the @ in your decoration is evaluated to being the decorator. In other words, @list2csv is not a shortcut to @list2csv(). If list2csv is called, it should return a decorator itself. Here’s how:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

import csv
import StringIO
 
class Tabs(csv.excel):
    delimiter = '\t'
 
def list2csv(func=None, dialect='excel'):
    if func is None:
        return lambda _: list2csv(_, dialect)
 
    def wrapper(*args, **kwargs):
        listValue = func(*args, **kwargs)
        fd = StringIO.StringIO()
        writer = csv.writer(fd, dialect)
        for row in listValue:
            writer.writerow(row)
        return fd.getvalue()
    return wrapper
 
@list2csv(dialect=Tabs)
def getList():
    return [
        ('First Name', 'Last Name',  'Profession'),
        ('Ken',        'Kinder',     'Software Engineer'),
        ('John',       'Stewart',    'Funny man'),
        ('Guido',      'Van Russum', 'Smart guy')
        ]
 
print getList()

This is a trick that lets you pass keyword arguments to the decorator. Notice lines 8 and 9, then 20. When this method is the called with a function, it behaves as normal, otherwise it returns a lambda to itself, with the arguments already specified.