Popular recipes by Dan McDougall

lreplace() and rreplace(): Replace the beginning and ends of a strings (Python)

2010-06-04T02:18:48-07:00

Python recipe 577252 by Dan McDougall (regex, replace, string).

Python newbies will often make the following mistake (I certainly have =):

>>> test = """this is a test:
... tis the season for mistakes."""
>>> for line in test.split('\n'):
...     print line.lstrip('this')
... 
 is a test
 the season for mistakes.

The mistake is assuming that lstrip() (or rstrip()) strips a string (whole) when it actually strips all of the provided characters in the given string. Python actually comes with no function to strip a string from the left-hand or right-hand side of a string so I wrote this (very simple) recipe to solve that problem. Here's the usage:

>>> test = """this is a test:
... tis the season for mistakes."""
>>> for line in test.split('\n'):
...     print lreplace('this', '', line)
... 
 is a test
tis the season for mistakes.

I really wish Python had these functions built into the string object. I think it would be a useful addition to the standard library. It would also be nicer to type this:

line.lreplace('this', '')

Instead of this:

lreplace('this','',line)

Convert strings like '5d' and '60s' to timedelta objects (Python)

2011-10-06T14:06:54-07:00

Python recipe 577894 by Dan McDougall (datetime, timedelta).

I wrote this little function for [Gate One](http://vimeo.com/24857127) (a web-based terminal emulator/SSH client)... It converts strings in the format of <num><character> into timedelta objects. It's not rocket science but maybe it'll save someone a few keystrokes :). Besides that, it comes with a really nice Sphinx-ready (reStructuredText) docstring with complete doctests.

Method-based URL dispatcher for the Tornado web server (Python)

2009-11-20T11:51:47-08:00

Python recipe 576958 by Dan McDougall (dispatcher, shortcuts, subclass, tornado, url, web). Revision 5.

The MethodDispatcher is a subclass of tornado.web.RequestHandler that will use the methods contained in subclasses of MethodDispatcher to handle requests. In other words, instead of having to make a new RequestHandler class for every URL in your application you can subclass MethodDispatcher and use the methods contained therein as your URLs.

The MethodDispatcher also adds the convenience of automatically passing arguments to your class methods. So there is no need to use Tornado's get_argument() method.

Example

To demonstrate the advantages of using MethodDispatcher I'll present a standard Tornado app with multiple URLs and re-write it using MethodDispatcher...

The standard Tornado way

class Foo(tornado.web.RequestHandler):
    def get(self):
        self.write('foo')

class Bar(tornado.web.RequestHandler):
    def get(self):
        self.write('bar')

class SimonSays(tornado.web.RequestHandler):
    def get(self):
        say = self.get_argument("say")
        self.write('Simon says, %s' % `say`)

application = tornado.web.Application([
    (r"/foo", Foo),
    (r"/bar", Bar),
    (r"/simonsays", SimonSays),
])

The MethodDispatcher way

class FooBar(MethodDispatcher):
    def foo(self):
        self.write("foo")

    def bar(self):
        self.write("bar")

    def simonsays(self, say):
        self.write("Simon Says, %s" % `say`)

application = tornado.web.Application([
    (r"/.*", FooBar)
])

Notes

As you can see from the above example, using the MethodDispatcher can significantly reduce the complexity of Tornado applications. Here's some other things to keep in mind when using the MethodDispatcher:

MethodDispatcher will ignore any methods that begin with an underscore (_). This prevents builtins and private methods from being exposed to the web.
The '/' path is special: It always maps to self.index().
MethodDispatcher does not require that your methods distinquish between GET and POST requests. Whether a GET or POST is performed the matching method will be called with any passed arguments or POSTed data. Because of the way this works you should not use get() and post() in your MethodDispatcher subclasses unless you want to override this functionality.
When an argument is passed with a single value (/simonsays?say=hello) the value passed to the argument will be de-listed. In other words, it will be passed to your method like so: {'say': 'hello'}. This overrides the default Tornado behavior which would return the value as a list: {'say': ['hello']}. If more than one value is passed MethodDispatcher will use the default behavior.

Python code minifier (Python)

2014-05-25T16:23:55-07:00

Python recipe 576704 by Dan McDougall (bz2, bzip2, comments, compression, docstring, embedded, gzip, minify, pack, regex, zlib). Revision 16.

Update 05/25/2014: Pyminifier 2.0 has been released and now lives on Github: https://github.com/liftoff/pyminifier (docs are here: http://liftoff.github.io/pyminifier/). The code below is very out-of-date but will be left alone for historical purposes.

Python Minifier: Reduces the size of Python code for use on embedded platforms. Performs the following:

Removes docstrings.
Removes comments.
Removes blank lines.
Minimizes code indentation.
Joins multiline pairs of parentheses, braces, and brackets (and removes extraneous whitespace within).
Preserves shebangs and encoding info (e.g. "# -- coding: utf-8 --")
NEW: Optionally, produces a bzip2 or gzip-compressed self-extracting python script containing the minified source for ultimate minification.

Update 09/23/2010: Version 1.4.1: Fixed an indentation bug when operators such as @ and open parens started a line.

Update 09/18/2010: Version 1.4:

Added some command line options to save the result to an output file.
Added the ability to save the result as a bzip2 or gzip-compressed self-extracting python script (which is kinda neat--try it!).
Updated some of the docstrings to provide more examples of what each function does.

Update 06/02/2010: Version 1.3: Rewrote several functions to use Python's built-in tokenizer module (which I just discovered despite being in Python since version 2.2). This negated the requirement for pyparsing and improved performance by an order of magnitude. It also fixed some pretty serious bugs with dedent() and reduce_operators().

PLEASE POST A COMMENT IF YOU ENCOUNTER A BUG!

Serve static web content from within a gzipped tarball to save space using CherryPy (Python)

2009-03-31T18:24:06-07:00

Python recipe 576706 by Dan McDougall (cherrypy, compression, embedded, gzip, html, http, network, routes, web, web_server).

This code lets you store all of your static website content inside a gzipped tarball while transparently serving it to HTTP clients on-demand. Perfect for embedded systems where space is limited.