If you’ve got Django view code that gets & sets session values, you’ll want to test it properly, and the standard “self.client” from Django’s TestCase doesn’t really give you a usable session.  So, here’s the method I’m using:

def stuff_session(client, dictionary):
    """Given a client (self.client in a unit test TestCase) set the session to the contents of
    the dictionary given"""
    from django.conf import settings
    from django.utils.importlib import import_module
    engine = import_module(settings.SESSION_ENGINE)
    store = engine.SessionStore()
    store.save()  # we need to make load() work, or the cookie isworthless
    client.cookies[settings.SESSION_COOKIE_NAME] = store.session_key
    session = client.session
    session.update(dictionary)
    session.save()
    # and now remember to re-login!

So, in my setUp() methods, I just call stuff_session(self.client, {‘key’: ‘value’}) and it all works out great.

$ git pull
You are not currently on a branch, so I cannot use any
'branch.<branchname>.merge' in your configuration file.
Please specify which remote branch you want to use on the command
line and try again (e.g. 'git pull <repository> <refspec>').
See git-pull(1) for details.

The solution (in this case, per the above directory) is to run:

$ cd /path/to/git/repository/from/above
$ git checkout master

I wish pip didn’t cause this problem. When you specfiy a git repository on the commandline, this should happen automatically. Maybe this has been fixed in pip 1.0 which was just released today.

    try:
        print "First"
        if some_condition:
            # What do I put here to break out of the try block?
        print "Second"
    except Exception as e:
        if e:
            print "Exception"
    print "Last"

(If some_condition is true, I want the output to print “First” and “Last”)

Neither break or continue works as expected, since “try” isn’t a loop. I could put the body of the try block in a function, and then at the “if some_condition” section, I could just return, but that seemed messy. I never found a clean enough solution, but one possibility is this wonky syntax:

for _ in [True]:
    try:
        print "First"
        if some_condition:
            # Now, since we're in a loop, we can break out of it.
            break
        print "Second"
    except Exception as e:
        if e:
            print "Exception"
            print type(e)

print "Last"

But, it’s kind of ugly, and not clear what’s going on, so I decided not to do it that way.

I’m really surprised that there isn’t a standard syntax for this. Something like “raise” but that isn’t an exception. I guess I could raise a special value and handle it specially in th except block, but that seems messy as well.

In addition, the packaged versions of pymacs+ropemacs for ubuntu 10.10 (and 11.04) are also kind of busted, because they complains with really odd errors.

Here’s the solution:

Install the latest, greatest versions of everything into your virtualenv:

. ./env/bin/activate
pip install -e hg+https://bitbucket.org/agr/rope#egg=rope
pip install -e hg+https://bitbucket.org/agr/ropemacs#egg=ropemacs
pip install -e hg+https://bitbucket.org/agr/ropemode#egg=ropemode
pip install -e git+https://github.com/pinard/Pymacs.git#egg=pymacs

Unfortunately, pymacs doesn’t cleanly install, so then need to:

cd env/src/pymacs
make

Once that’s done, you should have env/src/pymacs/pymacs.el. Great. Now you just need to import that from your .emacs file. So, add something that looks like this to your .emacs:

(setq virtual-env (getenv "VIRTUAL_ENV"))

(if (not (equal virtual-env 'nil))
      (setq load-path (append
                 (list (concat virtual-env "/src/pymacs" ))
                 load-path))
      (let ((foo 'bar))
      (require 'pymacs)
      (pymacs-load "ropemacs" "rope-")
      (setq ropemacs-enable-autoimport 't)
      ))

Activate your virtualenv, and run emacs from inside there, and you should be good to go.

If you’re using a web framework, you might have some support for doing this, but what about your other modules that you’d like to configure in a similar way?

What you sort of want to be able to say, anywhere, is something like this:

import config

if config.MODULE['parameter'] == 'value':
    # do something
else:
    # do something else

And, you want “import config” to automatically decide (via some means) if it’s in production or development.

Great, here’s a really simple pattern for you.

Make a directory named “config” put it somewhere on your python import path. (It’s okay if this is app.config or some_module.config, whatever you want.) Make the __init__ look like this:

class Config(object):
    pass

if some_condition:
    from config.production import ProductionConfig
    config = ProductionConfig
else:
    config = DevelopmentConfig

You need to write some_condition yourself. You’ll probably do something like check for existance of a file, check the hostname, look at an environment variable, whatever.

Then, create config/production.py and config/development.py and make them look pretty much like this:

from config import Config
class DevelopmentConfig(Config):
    MODULE = { 'param': 'value' }
    OTHER_MODULE = { 'other_param': 'other_value' }
    # etc.

Make sure that production and development configs both specify the same arguments. If you have shared things you want to configure, then you can make “base.py” or “shared.py” and derive from that.

Happy hacking!

<xml>
<name>Bob</name>
...

You can use this nice little function to convert it to a native Python object.  I’m using this to turn the results of the LinkedIn API from XML to Python, which then gets stored as JavaScript in MongoDB.

Set “force_list” to a list of field names that you know are list-values and it will convert those to lists in Python.  Yeah, that could be cleaner and more automatic.  Not really that proud of this, but it does work…

import xml.dom.minidom

def typeconvert(str_data):
    try:
        int_value = int(str_data)
        return int_value
    except:
        pass
    try:
        float_value = float(str_data)
        return float_value
    except:
        pass

    if str_data.lower() == 'false':
        return False
    if str_data.lower() == 'true':
        return True
    if str_data.lower() == 'null':
        return None

    return str_data

def xml_to_py(xml_text, force_list=[], convert_types=True):

    def setval(data, key, value):
        if key in force_list:
            if key not in data:
                data[key] = []
            data[key].append(value)
        else:
            if key in data:
                logging.warn("WARN: key %s, value %s in XML seems like a list" % (key, value))
                pass
            data[key] = value

    def recurse(node):
        nodename = node.nodeName
        result = {}
        if node.nodeType == xml.dom.Node.TEXT_NODE:
            nodetext = node.data.strip(' \n')
        else:
            nodetext = ''
        for child in node.childNodes:
            if child.nodeType == xml.dom.Node.TEXT_NODE:
                nodetext += child.data.strip(' \n')
            else:
                (newtext, newdata) = recurse(child)
                if newtext and newdata:
                    raise Exception("Can't have both text and data")
                if newtext != '':  # newtext could be an integer with value 0
                    if convert_types:
                        newtext = typeconvert(newtext)

                    setval(result, child.nodeName, newtext)
                elif newdata:
                    setval(result, child.nodeName, newdata)

        return (nodetext, result)

    dom = xml.dom.minidom.parseString(xml_text)
    (_text, pydict) = recurse(dom)
    return pydict

import pickle

d = {'a': 1}

s1 = pickle.dumps(d)
s2 = unicode(s1)

assert(s1 == s2)

d1 = pickle.loads(s1)
d2 = pickle.loads(s2)

assert(d1 == d2)

So, what do you think happens here? Are s1 and s2 equal? Are d1 and d2?

Well, hold on to your hats. The code doesn’t even execute through pickle.loads(s2). It throws this crazy error:

Traceback (most recent call last):
  File "/tmp/test.py", line 11, in <module>
    d2 = pickle.loads(s2)
  File "/usr/lib/python2.6/pickle.py", line 1374, in loads
    return Unpickler(file).load()
  File "/usr/lib/python2.6/pickle.py", line 858, in load
    dispatch[key](self)
KeyError: '\x00'

So, how’s that for totally insane unpredictable behavior?

class Dicty(dict, object):
    def __init__(self):
        self.__dict__ = self

d = Dicty()
d['foo'] = bar
print d.foo
d.foo = 'baz'
print d['foo']
print d
print dir(d)

I’ve seen people using Celery for this purpose, and it’s very well respected, but the setup is far from easy.  It has several fairly large dependencies, including RabbitMQ, or you have to use one of their “ghetto queue” solutions.  I tried the ghetto queue for MongoDB, and it furiously polled the database.  That’s not cool.

I was also finding that it had somewhat unpredictable behavior, and I actually wanted something more simple.  I wanted to use a flow like:

• Take any arbitrary function or method call, and “pickle it”
• Stick the pickled calls into a database (mongodb in my case)
• Pull out items from the DB and execute them.

Simple polling met my needs, and writing a queue in MongoDB is actually pretty simple, since they have atomic test-and-set primitives.

So, the only missing component was something that let me pickle method calls, and thus, I wrote a simple library to do it.  It’s called methodpickle and it’s on github.  Here’s a brief example of what it lets you do:

from methodpickle.defer import defer 

def factorial(x):
    if x == 1: return 1
    return x * factorial(x-1)

if __name__ == '__main__':
    deferred = defer(factorial, 123)
    deferred_str = pickle.dumps(deferred)

    # Now, take deferred_str, store it to a db, read it back again, whatever.
    call = pickle.loads(deferred_str)
    print call.run()

And, it even works with class methods, as long as ‘self’ is pickle-able. Cool!

def wrap(method):
    def call(*args, **kwargs):
        print "calling wrapped method"
        return method(*args, **kwargs)
    return call

@wrap
def some_function(arbitrary, arguments=None):
    print "%s %s" % (arbitrary, arguments)

And here’s a trivial class-based decorator:

class Wrap(object):
    def __init__(self, method):
        print "construct"
        self._method = method
    def __call__(self, *args, **kwargs):
        print "call"
        self._method(*args, **kwargs)

@Wrap
def some_function(*args, **kwargs):
    print "Inside %s %s" % (str(args), str(kwargs))