Question

I’d like to use a string as the sender for a custom Django signal but have run into some issues related to how Django’s unicode encoding of a model’s strings. Here’s a hopefully working short example illustrating the problem:

from django.dispatch import Signal
from django.db import models

example_signal = Signal(providing_args=["data"])

class Example(models.Model):
    example_field = models.CharField(max_length=32)
    def send_signal(self):
        example_signal.send(sender=self.example_field, data=self) # (arbitrarily using self as the signal payload)

def example_handler(sender, data=None):
    print "received data %s" % data

example_signal.connect(example_handler, sender=u'boogat')


... (after entering the django shell and importing the models)
>>> t = Example.objects.create(example_field='boogat')
>>> t.send_signal()
>>>  

I’ve skimmed through Django’s dispatcher.py code – in this case, the signals dispatcher appears to use the Python builtin id function to generate a unique id for whatever object is used as the sender. However, I can’t seem to figure out what I need to do to programmatically generate a string that, when sent to id(), is equivalent to Django’s unicode model string. I’ve tried str, repr, encode('UTF-8'), django.util.encodings, all to no avail.

At this point I’ve already implemented a workaround but I’d still like to understand what is going on… any input would be much appreciated!

Answer 1

I ran into a similar problem with signals and found what I think is a better solution.

I definitely prefer using the sender argument of connect to checks inside the handler if possible.

The problem as you say is object id(): two strings (not even just unicode strings!) with the same content may have different object ids. The solution is the intern() built-in which enters the given string into python’s internal identifier table (this is very similar to ruby’s Symbol).

If you use sender=intern(sender_string) on both send() and connect() things should work as expected.

Two important caveats:

1. intern() only works on str, not unicode – you will have to deal with encoding back to str, and you have to perform the same encoding for both send() and connect().
2. Python’s internal record of your interned string can be discarded by the garbage collector when it discards the reference to your interned string, so you have to make sure you keep it around.

A good way to deal with both problems is that you are probably only interested in signals from a few pre-defined strings, so just stick those in a configuration constant, already interned.

For example:

user_did_something = Signal(providing_args=["data"])

class User(models.Model):
    identifier = models.CharField(max_length=32)
    def send_signal(self):
        user_did_something.send(sender=intern(self.example_field.encode('utf8')), data=self) 


ADMIN_USER = intern('admin')
BIG_ADMIN_USER = intern(u'größer admin'.encode('utf8'))


user_did_something.connect(admin_behavior, sender=ADMIN_USER)
user_did_something.connect(big_admin_behavior, sender=BIG_ADMIN_USER)

BIG_ADMIN_USER will print out to gibberish if not decoded back to a unicode string, but I suspect most such identifiers will be ascii.