>>> 'foo,bar'.split(',')
['foo', 'bar']

But here’s the problem:

>>> "foo,bar,'spam,eggs'".split(',')
['foo', 'bar', "'spam", "eggs'"]

Sometimes you want a csv-style split without the hassle of actually using Python’s otherwise excellent full-blown csv parser module.

So I wrote something that lets you do this:

>>> from csvsplit import csvsplit
>>> csvsplit('foo,bar,"spam,eggs"')
['foo', 'bar', 'spam,eggs']
>>> csvsplit('foo,bar,"spam,eggs"', delimiter='\t')
['foo,bar,"spam,eggs"']
>>> csvsplit('foo\tbar\t"spam\t\teggs"', delimiter='\t')
['foo', 'bar', 'spam\t\teggs']

Download it here. Enjoy!

I’ll start, as a lonely developer with no real following, by saying that I agree with Steve Jobs about Flash. I wouldn’t package it on the iPhone either and I haven’t installed it on my Nexus One, nor do I plan to. But having said that, there’s still a certain elitism and entitlement that Jobs needs to be called out on, and I hope I’m not alone in thinking this. Jobs starts by mentioning that Flash is proprietary, and while Apple releases proprietary things too (you think?), they, according to Jobs, prefer open standards:

Apple even creates open standards for the web. For example, Apple began with a small open source project and created WebKit, a complete open-source HTML5 rendering engine that is the heart of the Safari web browser used in all our products. WebKit has been widely adopted. Google uses it for Android’s browser, Palm uses it, Nokia uses it, and RIM (Blackberry) has announced they will use it too. Almost every smartphone web browser other than Microsoft’s uses WebKit. By making its WebKit technology open, Apple has set the standard for mobile web browsers.

Except, here’s the thing. Apple did not create WebKit. They based it on KHTML which is LGPL. They were required by law to keep it Open Source. More importantly, Jobs praises the HTML5 standard as the future for bringing video to the web. I look forward to that day myself, but I’m troubled that the biggest threat to HTML5 isn’t Adobe, but Apple. Steve writes,

To achieve long battery life when playing video, mobile devices must decode the video in hardware; decoding it in software uses too much power. Many of the chips used in modern mobile devices contain a decoder called H.264 – an industry standard that is used in every Blu-ray DVD player and has been adopted by Apple, Google (YouTube), Vimeo, Netflix and many other companies.

That’s great and all but H.264 is a closed codec and Apple’s the only browser house that has committed to only implement H.264, not the standardsy alternative, Ogg Theora. That is to say, not only is Apple supporting the closed codec, but they’ve refused to support an open one, even though doing so would cost them almost nothing in terms of development time. Apple is a member of the MPEG group, which collects royalties on H.264, so that might explain their motivation. Google, by contrast, acquired VP8 to help bridge the divide.

Regarding developers, Steve continues,

We know from painful experience that letting a third party layer of software come between the platform and the developer ultimately results in sub-standard apps and hinders the enhancement and progress of the platform. If developers grow dependent on third party development libraries and tools, they can only take advantage of platform enhancements if and when the third party chooses to adopt the new features. We cannot be at the mercy of a third party deciding if and when they will make our enhancements available to our developers.

It’s certainly true that natively developed apps are usually better. Most cross-platform technologies are themselves meta-platforms that are, at best, inconsistent with the rest of the environment (Java’s GUI toolkit comes to mind). But barring third party developers from using cross-platform tools because those tools might not implement all of Apple’s new features is nonsensical. Even using Apple’s own SDK, developers might take their time in updating their applications, or they may not use Apple’s new APIs at all. Will Apple ban all apps that aren’t using enough new API calls?

Apple isn’t defending its right to innovate, but rather, it’s quashing everyone else’s right to innovate on the iPhone platform. There will be fewer non-native apps on the Apple Store, but that just means there will be fewer apps period. Hardly a win for users.

Finally, Steve writes,

Flash was designed for PCs using mice, not for touch screens using fingers. For example, many Flash websites rely on “rollovers”, which pop up menus or other elements when the mouse arrow hovers over a specific spot. Apple’s revolutionary multi-touch interface doesn’t use a mouse, and there is no concept of a rollover. Most Flash websites will need to be rewritten to support touch-based devices. If developers need to rewrite their Flash websites, why not use modern technologies like HTML5, CSS and JavaScript?

So are web sites that use onmouseover not allowed on the iPhone?

Flash is a bad piece of software. It’s proprietary, slow, buggy, and just plain bad. But users have a right to install it if they want. I’m most troubled by sentences like this:

We don’t want to reduce the reliability and security of our iPhones, iPods and iPads by adding Flash.

But they aren’t your iPhones, iPods, and iPads. They’re bought, not leased, and they belong to the users who paid for them. And if you own a device, you should have the right to decide what software it runs without having to “jailbreak” it.

That’s why I bought a Nexus One. If I want to install apps that aren’t available on the Android Market, I can do that with one touch. If I want to install a third party ROM, I’m simply warned that doing so will void my warranty (Google made no attempts to prevent you from doing this). I feel like I own the device. And I do. iPhone users should enjoy the same privilege of controlling their computing own destinies.

Most of the ROMs on xda-developers are one-off builds from hackers who are experimenting. I don’t want to experiment — I’m looking for less Slackware, more Ubuntu on my phone. Over a year ago, I installed CyanogenMod, as it seemed like the most consumer-friendly ROM out there. For one, instead of a poorly formatted posting on xda-developers, it has an actual website. It also boasts an automatic updater, lots of nice features like tethering and a caller blacklist, and even a stable-v-unstable build schedule.

Unfortunately, CyanogenMod has become increasingly unstable for me. That’s probably due to a combination of things, including Cyanogen’s unfortunate proclivity to bloat-up the stock firmware with features and experimental kernel improvements. Another cause for the problem is likely attributable to Google’s position of only half open sourcing Android.

What I’m looking for is something like the stock ROM, with root, tethering, auto-update, and not much else. I don’t think it’s out there. Maybe I should figure out how hard it is to do it myself.

"""
Adds a color chooser to WingIDE.
 
Copyright (c) 2010, Ken Kinder All rights reserved.
 
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
 
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""
 
from guiutils import wgtk as gtk
import wingapi
 
def _getclipboard():
    editor = wingapi.gApplication.GetActiveEditor()
    doc = editor.GetDocument()
    start, end = editor.GetSelection()
    return doc.GetCharRange(start, end)
 
def _setclipboard(txt):
    editor = wingapi.gApplication.GetActiveEditor()
    doc = editor.GetDocument()
    start, end = editor.GetSelection()
 
    doc.BeginUndoAction()
    try:
        doc.DeleteChars(start, end-1)
        doc.InsertChars(start, txt)
    finally:
        doc.EndUndoAction()
 
def colorpicker():
    w = gtk.ColorSelectionDialog(title="Color Picker")
    w.colorsel.set_has_palette(True)
 
    if _getclipboard():
        w.colorsel.set_current_color(gtk.gdk.color_parse(_getclipboard()))
 
    response = w.run()
    if response == gtk.RESPONSE_OK:
        r = ('%02X' % w.colorsel.get_current_color().red)[0:2]
        g = ('%02X' % w.colorsel.get_current_color().green)[0:2]
        b = ('%02X' % w.colorsel.get_current_color().blue)[0:2]
        _setclipboard('#%s%s%s' % (r, g, b))
 
    w.hide()
    w.destroy()

Dump this code in a file in your ~/.wingide3/scripts directory, run reload-scripts, and you have a colorpicker command. It will show a gtk color picker and insert that color in your code in #rrggbb format. If you have a color selected in your buffer at the time you invoke the command, it will be parsed, be the default in the editor, and replaced when you’re done.

It doesn’t add any menu items. You just have to use the command directly or add your on shortcuts.

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.