Hello,
I'm a strong proponent of the observer pattern, and this is what I'd like to be able to do in my Django models.py:
class AModel(Model):
__metaclass__ = SomethingMagical
@post_save(AnotherModel)
@classmethod
def observe_another_model_saved(klass, sender, instance, created, **kwargs):
pass
@pre_init('YetAnotherModel')
@classmethod
def observe_yet_another_model_initializing(klass, sender, *args, **kwargs):
pass
@post_delete('DifferentApp.SomeModel')
@classmethod
def observe_some_model_deleted(klass, sender, **kwargs):
pass
This would connect a signal with sender = the decorator's argument and receiver = the decorated method. Right now my signal connection code all exists in __init__.py which is okay, but a little unmaintainable. I want this code all in one place, the models.py file.
Thanks to helpful feedback from the community I'm very close (I think.) (I'm using a metaclass solution instead of the class decorator solution in the previous question/answer because you can't set attributes on classmethods, which I need.)
I am having a strange error I don't understand. At the end of my post are the contents of a models.py that you can pop into a fresh project/application to see the error. Set your database to sqlite and add the application to installed apps.
This is the error:
Validating models...
Unhandled exception in thread started by
Traceback (most recent call last):
File "/Library/Python/2.6/site-packages//lib/python2.6/site-packages/django/core/management/commands/runserver.py", line 48, in inner_run
File "/Library/Python/2.6/site-packages/django/core/management/base.py", line 253, in validate
raise CommandError("One or more models did not validate:\n%s" % error_text)
django.core.management.base.CommandError: One or more models did not validate:
local.myothermodel: 'my_model' has a relation with model MyModel, which has either not been installed or is abstract.
I've indicated a few different things you can comment in/out to fix the error. First, if you don't modify the attrs sent to the metaclass's __new__, then the error does not arise. (Note even if you copy the dictionary element by element into a new dictionary, it still fails; only using the exact attrs dictionary works.) Second, if you reference the first model by class rather than by string, the error also doesn't arise regardless of what you do in __new__.
I appreciate your help. I'll be githubbing the solution if and when it works. Maybe other people would enjoy a simplified way to use Django signals to observe application happenings.
#models.py
from django.db import models
from django.db.models.base import ModelBase
from django.db.models import signals
import pdb
class UnconnectedMethodWrapper(object):
sender = None
method = None
signal = None
def __init__(self, signal, sender, method):
self.signal = signal
self.sender = sender
self.method = method
def post_save(sender):
return _make_decorator(signals.post_save, sender)
def _make_decorator(signal, sender):
def decorator(view):
return UnconnectedMethodWrapper(signal, sender, view)
return decorator
class ConnectableModel(ModelBase):
"""
A meta class for any class that will have static or class methods
that need to be connected to signals.
"""
def __new__(cls, name, bases, attrs):
unconnecteds = {}
## NO WORK
newattrs = {}
for name, attr in attrs.iteritems():
if isinstance(attr, UnconnectedMethodWrapper):
unconnecteds[name] = attr
newattrs[name] = attr.method #replace the UnconnectedMethodWrapper with the method it wrapped.
else:
newattrs[name] = attr
## NO WORK
# newattrs = {}
# for name, attr in attrs.iteritems():
# newattrs[name] = attr
## WORKS
# newattrs = attrs
new = super(ConnectableModel, cls).__new__(cls, name, bases, newattrs)
for name, unconnected in unconnecteds.iteritems():
_connect_signal(unconnected.signal, unconnected.sender, getattr(new, name), new._meta.app_label)
return new
def _connect_signal(signal, sender, receiver, default_app_label):
# full implementation also accepts basestring as sender and will look up model accordingly
signal.connect(sender=sender, receiver=receiver)
class MyModel(models.Model):
__metaclass__ = ConnectableModel
@post_save('In my application this string matters')
@classmethod
def observe_it(klass, sender, instance, created, **kwargs):
pass
@classmethod
def normal_class_method(klass):
pass
class MyOtherModel(models.Model):
## WORKS
# my_model = models.ForeignKey(MyModel)
## NO WORK
my_model = models.ForeignKey('MyModel')
