def contribute_to_class(self, cls, name): super(FileField, self).contribute_to_class(cls, name) setattr(cls, 'get_%s_filename' % self.name, curry(cls._get_FIELD_filename, field=self)) setattr(cls, 'get_%s_url' % self.name, curry(cls._get_FIELD_url, field=self)) setattr(cls, 'get_%s_size' % self.name, curry(cls._get_FIELD_size, field=self)) setattr(cls, 'save_%s_file' % self.name, lambda instance, filename, raw_contents, save=True: instance._save_FIELD_file(self, filename, raw_contents, save)) dispatcher.connect(self.delete_file, signal=signals.post_delete, sender=cls)
def set_defaults(app, *defaults): "Installs a set of default values during syncdb processing" from django.core.exceptions import ImproperlyConfigured from django.dispatch import dispatcher from django.db.models import signals from dbsettings.loading import get_setting_storage, set_setting_value if not defaults: raise ImproperlyConfigured( "No defaults were supplied to set_defaults.") app_label = app.__name__.split('.')[-2] def install_settings(app, created_models, verbosity=2): printed = False for class_name, attribute_name, value in defaults: if not get_setting_storage(app.__name__, class_name, attribute_name): if verbosity >= 2 and not printed: # Print this message only once, and only if applicable print "Installing default settings for %s" % app_label printed = True try: set_setting_value(app.__name__, class_name, attribute_name, value) except: raise ImproperlyConfigured("%s requires dbsettings." % app_label) dispatcher.connect(install_settings, sender=app, signal=signals.post_syncdb, weak=False)
def set_defaults(app, *defaults): "Installs a set of default values during syncdb processing" from django.core.exceptions import ImproperlyConfigured from django.dispatch import dispatcher from django.db.models import signals from dbsettings.loading import get_setting_storage, set_setting_value if not defaults: raise ImproperlyConfigured("No defaults were supplied to set_defaults.") app_label = app.__name__.split('.')[-2] def install_settings(app, created_models, verbosity=2): printed = False for class_name, attribute_name, value in defaults: if not get_setting_storage(app.__name__, class_name, attribute_name): if verbosity >= 2 and not printed: # Print this message only once, and only if applicable print "Installing default settings for %s" % app_label printed = True try: set_setting_value(app.__name__, class_name, attribute_name, value) except: raise ImproperlyConfigured("%s requires dbsettings." % app_label) dispatcher.connect(install_settings, sender=app, signal=signals.post_syncdb, weak=False)
def contribute_to_class(self, cls, name): super(FileField, self).contribute_to_class(cls, name) setattr(cls, 'get_%s_filename' % self.name, curry(cls._get_FIELD_filename, field=self)) setattr(cls, 'get_%s_url' % self.name, curry(cls._get_FIELD_url, field=self)) setattr(cls, 'get_%s_size' % self.name, curry(cls._get_FIELD_size, field=self)) setattr(cls, 'save_%s_file' % self.name, lambda instance, filename, raw_contents, save=True: instance._save_FIELD_file(self, filename, raw_contents, save)) dispatcher.connect(self.delete_file, signal=signals.post_delete, sender=cls)
def version_model(model): """ Based on the passed model, build a second model to store versioning information. Register functions to write version changes on save and delete of the original model NOTE: be sure to use strong references for signal connections so that inner funcs don't get garbage collected """ version_model = _build_version_model(model) _decorate_model(model,version_model) def record_change(instance,change_type): version_instance = _version_from_instance(instance,version_model) version_instance.change_type = change_type version_instance.save() def record_save(sender,instance,signal, *args, **kwargs): # Record the save to the shadow table record_change(instance,"SAVE") dispatcher.connect(record_save,signal=signals.post_save,sender=model,weak=False) def record_delete(sender,instance,signal,*args,**kwargs): # Record the delete to the shadow table record_change(instance,"DELETE") dispatcher.connect(record_delete,signal=signals.pre_delete,sender=model,weak=False) setattr(model,'version_model',version_model) return version_model
def create_or_update(self, instance, timestamp=None, tags="", source="INTERACTIVE", source_id=""): """ Create or update an Item from some instace. """ # If the instance hasn't already been saved, save it first. This # requires disconnecting the post-save signal that might be sent to # this function (otherwise we could get an infinite loop). if instance._get_pk_val() is None: try: dispatcher.disconnect(self.create_or_update, signal=signals.post_save, sender=type(instance)) except dispatcher.errors.DispatcherError: reconnect = False else: reconnect = True instance.save() if reconnect: dispatcher.connect(self.create_or_update, signal=signals.post_save, sender=type(instance)) # Make sure the item "should" be registered. if not getattr(instance, "jellyrollable", True): return # Check to see if the timestamp is being updated, possibly pulling # the timestamp from the instance. if hasattr(instance, "timestamp"): timestamp = instance.timestamp if timestamp is None: update_timestamp = False timestamp = datetime.datetime.now() else: update_timestamp = True # Ditto for tags. if not tags: for f in instance._meta.fields: if isinstance(f, TagField): tags = getattr(instance, f.attname) break # Create the Item object. ctype = ContentType.objects.get_for_model(instance) item, created = self.get_or_create( content_type = ctype, object_id = instance._get_pk_val(), defaults = dict( timestamp = timestamp, source = source, source_id = source_id, tags = tags, ) ) item.tags = tags item.source = source item.source_id = source_id if update_timestamp: item.timestamp = timestamp # Save and return the item. item.save() return item
def process_request(self, request): self.time_started = time.time() self.templates_used = [] self.contexts_used = [] self.sql_offset_start = len(connection.queries) dispatcher.connect(self._storeRenderedTemplates, signal=template_rendered)
def _save(self, instance=None): if not self.auto_rename: return if instance == None: return if not instance._get_pk_val(): # NEW OBJECT, connect to the post_save for renaming dispatcher.connect(self._save_new, signals.post_save, sender=instance) return image = getattr(instance, self.attname) if self.name_field: image = rename_by_field(image, '%s-%s-%s' \ % (instance.__class__.__name__, self.name, getattr(instance, self.name_field) ) ) else: # XXX this needs testing, maybe it can generate too long image names (max is 100) image = rename_by_field(image, '%s-%s-%s' \ % (instance.__class__.__name__, self.name, instance._get_pk_val() ) ) setattr(instance, self.attname, image)
def request(self, **request): """ The master request method. Composes the environment dictionary and passes to the handler, returning the result of the handler. Assumes defaults for the query environment, which can be overridden using the arguments to the request. """ environ = { 'HTTP_COOKIE': self.cookies, 'PATH_INFO': '/', 'QUERY_STRING': '', 'REQUEST_METHOD': 'GET', 'SCRIPT_NAME': None, 'SERVER_NAME': 'testserver', 'SERVER_PORT': 80, 'SERVER_PROTOCOL': 'HTTP/1.1', } environ.update(self.defaults) environ.update(request) # Curry a data dictionary into an instance of # the template renderer callback function data = {} on_template_render = curry(store_rendered_templates, data) dispatcher.connect(on_template_render, signal=signals.template_rendered) # Capture exceptions created by the handler dispatcher.connect(self.store_exc_info, signal=got_request_exception) response = self.handler(environ) # Add any rendered template detail to the response # If there was only one template rendered (the most likely case), # flatten the list to a single element for detail in ('template', 'context'): if data.get(detail): if len(data[detail]) == 1: setattr(response, detail, data[detail][0]); else: setattr(response, detail, data[detail]) else: setattr(response, detail, None) # Look for a signalled exception and reraise it if self.exc_info: raise self.exc_info[1], None, self.exc_info[2] # Update persistent cookie and session data if response.cookies: self.cookies.update(response.cookies) if 'django.contrib.sessions' in settings.INSTALLED_APPS: from django.contrib.sessions.middleware import SessionWrapper cookie = self.cookies.get(settings.SESSION_COOKIE_NAME, None) if cookie: self.session = SessionWrapper(cookie.value) return response
def contribute_to_class(self, cls, name): super(TagField, self).contribute_to_class(cls, name) # Make this object the descriptor for field access. setattr(cls, self.name, self) # Save tags back to the database post-save dispatcher.connect(self._save, signal=signals.post_save, sender=cls)
def contribute_to_class(self, cls, name): super(TagField, self).contribute_to_class(cls, name) # Make this object the descriptor for field access. setattr(cls, self.name, self) # Save tags back to the database post-save dispatcher.connect(self._save, signal=signals.post_save, sender=cls)
def register(model, parent_attr='parent', left_attr='lft', right_attr='rght', tree_id_attr='tree_id', level_attr='level', tree_manager_attr='tree', order_insertion_by=None): """ Sets the given model class up for Modified Preorder Tree Traversal. """ if model in registry: raise AlreadyRegistered(_('The model %s has already been registered.') % model.__name__) registry.append(model) # Add tree options to the model's Options opts = model._meta opts.parent_attr = parent_attr opts.right_attr = right_attr opts.left_attr = left_attr opts.tree_id_attr = tree_id_attr opts.level_attr = level_attr opts.tree_manager_attr = tree_manager_attr opts.order_insertion_by = order_insertion_by opts.get_field(left_attr).null = True opts.get_field(left_attr).blank = True # Add tree fields if they do not exist for attr in [left_attr, right_attr, tree_id_attr, level_attr]: try: opts.get_field(attr) except FieldDoesNotExist: PositiveIntegerField( db_index=True, editable=False).contribute_to_class(model, attr) # Add tree methods for model instances setattr(model, 'get_ancestors', models.get_ancestors) setattr(model, 'get_children', models.get_children) setattr(model, 'get_descendants', models.get_descendants) setattr(model, 'get_descendant_count', models.get_descendant_count) setattr(model, 'get_next_sibling', models.get_next_sibling) setattr(model, 'get_previous_sibling', models.get_previous_sibling) setattr(model, 'get_root', models.get_root) setattr(model, 'get_siblings', models.get_siblings) setattr(model, 'insert_at', models.insert_at) setattr(model, 'is_child_node', models.is_child_node) setattr(model, 'is_leaf_node', models.is_leaf_node) setattr(model, 'is_root_node', models.is_root_node) setattr(model, 'move_to', models.move_to) # Add a custom tree manager TreeManager(parent_attr, left_attr, right_attr, tree_id_attr, level_attr).contribute_to_class(model, tree_manager_attr) setattr(model, '_tree_manager', getattr(model, tree_manager_attr)) # Set up signal receivers to manage the tree when instances of the # model are about to be created, have their parent changed or be # deleted. dispatcher.connect(pre_save, signal=model_signals.pre_save, sender=model) dispatcher.connect(pre_delete, signal=model_signals.pre_delete, sender=model)
def connect(self): """ Hooks up the moderation methods to pre- and post-save signals from the comment models. """ for model in (Comment, FreeComment): dispatcher.connect(self.pre_save_moderation, sender=model, signal=signals.pre_save) dispatcher.connect(self.post_save_moderation, sender=model, signal=signals.post_save)
def contribute_to_class(self, cls, name): super(JSONField, self).contribute_to_class(cls, name) dispatcher.connect(self.post_init, signal=signals.post_init, sender=cls) def get_json(model_instance): return dumps(getattr(model_instance, self.attname, None)) setattr(cls, 'get_%s_json' % self.name, get_json) def set_json(model_instance, json): return setattr(model_instance, self.attname, loads(json)) setattr(cls, 'set_%s_json' % self.name, set_json)
def contribute_to_class(self, cls, name): super(JSONField, self).contribute_to_class(cls, name) dispatcher.connect(self.post_init, signal=signals.post_init, sender=cls) def get_json(model_instance): return dumps(getattr(model_instance, self.attname, None)) setattr(cls, 'get_%s_json' % self.name, get_json) def set_json(model_instance, json): return setattr(model_instance, self.attname, loads(json)) setattr(cls, 'set_%s_json' % self.name, set_json)
def contribute_to_class(self, cls, name): # Make sure the fields exist (these raise FieldDoesNotExist, # which is a fine error to raise here) self.name = name self.model = cls self.cache_attr = "_%s_cache" % name # For some reason I don't totally understand, using weakrefs here doesn't work. dispatcher.connect(self.instance_pre_init, signal=signals.pre_init, sender=cls, weak=False) # Connect myself as the descriptor for this field setattr(cls, name, self)
def contribute_to_class(self, cls, name): # Make sure the fields exist (these raise FieldDoesNotExist, # which is a fine error to raise here) self.name = name self.model = cls self.cache_attr = "_%s_cache" % name # For some reason I don't totally understand, using weakrefs here doesn't work. dispatcher.connect(self.instance_pre_init, signal=signals.pre_init, sender=cls, weak=False) # Connect myself as the descriptor for this field setattr(cls, name, self)
def contribute_to_class(cls, main_cls, name): """ Handle the inner 'Translation' class. """ # delay the creation of the *Translation until the master model is # fully created connect(cls.finish_multilingual_class, signal=signals.class_prepared, sender=main_cls, weak=False) # connect the post_save signal on master class to a handler # that saves translations connect(translation_save_translated_fields, signal=signals.post_save, sender=main_cls)
def post_article_comment_save(sender,instance): if instance.content_type == ContentType.objects.get_for_model(Article): ym=instance.get_content_object() from django.core.mail import send_mail from django.template import Context, loader subject = 'New Comment by %s on %s'%(instance.user.username,ym.title) message_template = loader.get_template('comment_notification_email.txt') message_context = Context({ 'comment':instance,"content_object":ym}) message = message_template.render(message_context) send_mail(subject, message,settings.DEFAULT_FROM_EMAIL,[ym.user.email]) dispatcher.connect( post_article_comment_save, sender=Comment,signal=models.signals.post_save )
def contribute_to_class(self, cls, name): super(S3FileField, self).contribute_to_class(cls, name) models.CharField(maxlength=200, blank=self.blank, null=self.null).contribute_to_class(cls, "%s_key"%(self.name)) models.CharField(maxlength=200, blank=self.blank, null=self.null, default=(self.bucket or settings.DEFAULT_BUCKET)).contribute_to_class(cls, "%s_bucket"%(self.name)) models.CharField(maxlength=200, blank=True, null=True, default="").contribute_to_class(cls, "%s_content_type"%(self.name)) models.IntegerField(blank=True, null=True).contribute_to_class(cls, "%s_size"%(self.name)) if self.is_image: models.IntegerField(blank=True, null=True).contribute_to_class(cls, "%s_width"%(self.name)) models.IntegerField(blank=True, null=True).contribute_to_class(cls, "%s_height"%(self.name)) # Getter for the file url def get_url(instance, field): return field.get_url(instance) setattr(cls, 'get_%s_url' % self.name, curry(get_url, field=self)) dispatcher.connect(self.delete_file, signal=signals.post_delete, sender=cls)
def finish_multilingual_class(cls, *args, **kwargs): """ Create a model with translations of a multilingual class. """ main_cls = kwargs['sender'] translation_model_name = main_cls.__name__ + "Translation" # create the model with all the translatable fields class TransMeta: ordering = ('language_id',) unique_together = (('master', 'language_id'),) db_table = main_cls._meta.db_table + 'translation' app_label = main_cls._meta.app_label trans_attrs = cls.__dict__.copy() trans_attrs['Meta'] = TransMeta trans_attrs['language_id'] = models.IntegerField(blank=False, null=False, core=True, choices=get_language_choices(), db_index=True) trans_attrs['master'] = TranslationForeignKey(main_cls, blank=False, null=False, edit_inline=TransBoundRelatedObject, related_name='translations', num_in_admin=get_language_count(), min_num_in_admin=get_language_count(), num_extra_on_change=0) trans_attrs['__str__'] = lambda self: ("%s object, language_code=%s" % (translation_model_name, get_language_code(self.language_id))) trans_model = ModelBase(translation_model_name, (models.Model,), trans_attrs) trans_model._meta.translated_fields = cls.create_translation_attrs(main_cls) main_cls._meta.translation_model = trans_model main_cls.get_translation = get_translation main_cls.fill_translation_cache = fill_translation_cache # Note: don't fill the translation cache in post_init, as all # the extra values selected by QAddTranslationData will be # assigned AFTER init() # connect(fill_translation_cache, signal=signals.post_init, # sender=main_cls) # connect the pre_save signal on translation class to a # function removing previous translation entries. connect(translation_overwrite_previous, signal=signals.pre_save, sender=trans_model, weak=False)
def register_custom_permissions(permissions, sender): def mk_permissions(permissions, app, verbosity): # retrieve actual appname string from module instance appname = app.__name__.lower().split('.')[-2] # create a content type for the app ct, created = ContentType.objects.get_or_create(model='', app_label=appname, defaults={'name': appname}) if created and verbosity >= 2: print "Adding custom content type '%s'" % ct # create permissions for codename, name in permissions: p, created = Permission.objects.get_or_create(codename=codename, content_type__pk=ct.id, defaults={'name': name, 'content_type': ct}) if created and verbosity >= 2: print "Adding custom permission '%s'" % p dispatcher.connect(lambda app, verbosity: mk_permissions(permissions, app, verbosity), sender=sender, signal=signals.post_syncdb, weak=False)
def register_custom_permissions(permissions, sender): def mk_permissions(permissions, app, verbosity): # retrieve actual appname string from module instance appname = app.__name__.lower().split('.')[-2] # create a content type for the app ct, created = ContentType.objects.get_or_create(model='', app_label=appname, defaults={'name': appname}) if created and verbosity >= 2: print "Adding custom content type '%s'" % ct # create permissions for codename, name in permissions: p, created = Permission.objects.get_or_create(codename=codename, content_type__pk=ct.id, defaults={'name': name, 'content_type': ct}) if created and verbosity >= 2: print "Adding custom permission '%s'" % p dispatcher.connect(lambda app, verbosity: mk_permissions(permissions, app, verbosity), sender=sender, signal=signals.post_syncdb, weak=False)
def _save(self, instance=None): if not self.auto_rename: return if instance == None: return if not instance._get_pk_val(): # NEW OBJECT, connect to the post_save for renaming dispatcher.connect(self._save_new, signals.post_save, sender=instance) return image = getattr(instance, self.attname) if self.name_field: image = rename_by_field(image, '%s-%s-%s' \ % (instance.__class__.__name__, self.name, getattr(instance, self.name_field) ) ) else: # XXX this needs testing, maybe it can generate too long image names (max is 100) image = rename_by_field(image, '%s-%s-%s' \ % (instance.__class__.__name__, self.name, instance._get_pk_val() ) ) setattr(instance, self.attname, image)
def request(self, **request): """ The master request method. Composes the environment dictionary and passes to the handler, returning the result of the handler. Assumes defaults for the query environment, which can be overridden using the arguments to the request. """ environ = { 'HTTP_COOKIE': self.cookies, 'PATH_INFO': '/', 'QUERY_STRING': '', 'REQUEST_METHOD': 'GET', 'SCRIPT_NAME': '', 'SERVER_NAME': 'testserver', 'SERVER_PORT': 80, 'SERVER_PROTOCOL': 'HTTP/1.1', } environ.update(self.defaults) environ.update(request) # Curry a data dictionary into an instance of the template renderer # callback function. data = {} on_template_render = curry(store_rendered_templates, data) dispatcher.connect(on_template_render, signal=signals.template_rendered) # Capture exceptions created by the handler. dispatcher.connect(self.store_exc_info, signal=got_request_exception) try: response = self.handler(environ) except TemplateDoesNotExist as e: # If the view raises an exception, Django will attempt to show # the 500.html template. If that template is not available, # we should ignore the error in favor of re-raising the # underlying exception that caused the 500 error. Any other # template found to be missing during view error handling # should be reported as-is. if e.args != ('500.html',): raise # Look for a signalled exception, clear the current context # exception data, then re-raise the signalled exception. # Also make sure that the signalled exception is cleared from # the local cache! if self.exc_info: exc_info = self.exc_info self.exc_info = None raise exc_info[1].with_traceback(exc_info[2]) # Save the client and request that stimulated the response. response.client = self response.request = request # Add any rendered template detail to the response. # If there was only one template rendered (the most likely case), # flatten the list to a single element. for detail in ('template', 'context'): if data.get(detail): if len(data[detail]) == 1: setattr(response, detail, data[detail][0]); else: setattr(response, detail, data[detail]) else: setattr(response, detail, None) # Update persistent cookie data. if response.cookies: self.cookies.update(response.cookies) return response
""" Creates the default Site object. """ from django.dispatch import dispatcher from django.db.models import signals from django.contrib.sites.models import Site from django.contrib.sites import models as site_app def create_default_site(app, created_models, verbosity): if Site in created_models: if verbosity >= 2: print("Creating example.com Site object") s = Site(domain="example.com", name="example.com") s.save() Site.objects.clear_cache() dispatcher.connect(create_default_site, sender=site_app, signal=signals.post_syncdb)
# SIGNALS AND LISTENERS from django.db.models import signals # Show def show_pre_save(sender, instance, signal, *args, **kwargs): instance.slug = slugify(instance.name) instance.group = slugify(instance.group) if signals_refactored: signals.pre_save.connect(show_pre_save, sender=Show) else: dispatcher.connect(show_pre_save, signal=signals.pre_save, sender=Show) # CreditsLog def creditslog_post_save(sender, instance, signal, *args, **kwargs): if not instance.saved_to_ad: instance.ad.view_credits += instance.view_credits instance.ad.click_credits += instance.click_credits instance.ad.save() instance.saved_to_ad = True instance.save() if signals_refactored: signals.post_save.connect(creditslog_post_save, sender=CreditsLog)
GET_ITERATOR_CHUNK_SIZE = 100 def ensure_default_manager(sender): cls = sender if not hasattr(cls, '_default_manager'): # Create the default manager, if needed. try: cls._meta.get_field('objects') raise ValueError, "Model %s must specify a custom Manager, because it has a field named 'objects'" % cls.__name__ except FieldDoesNotExist: pass cls.add_to_class('objects', Manager()) dispatcher.connect(ensure_default_manager, signal=signals.class_prepared) class Manager(object): # Tracks each time a Manager instance is created. Used to retain order. creation_counter = 0 def __init__(self): super(Manager, self).__init__() # Increase the creation counter, and save our local copy. self.creation_counter = Manager.creation_counter Manager.creation_counter += 1 self.model = None def contribute_to_class(self, model, name): # TODO: Use weakref because of possible memory leak / circular reference.
cache = CacheState(hash=hash) get_avatar(cache, site, email) try: cache.save() if cache.enabled: return (urlparse.urljoin(settings.MEDIA_URL, os.path.join(AVATARS_CACHE_DIR, hash + '.png')), dict(width = cache.actual_width, height = cache.actual_height)) except Exception: logger.exception("can't save avatar cache") return (None, dict(width=0, height=0)) def comment_postsave(sender, instance): hash = gen_hash(instance.author_email, instance.author_site) try: cache = CacheState.objects.get(hash=hash) cache.expire_after = datetime.datetime.today() cache.save() except CacheState.DoesNotExist: pass if __name__ == 'avatars.models': from django.dispatch import dispatcher from django.db.models import signals try: from lfcomments.models import Comment dispatcher.connect(comment_postsave, signal=signals.post_save, sender=Comment) except Exception, e: logging.warning('post_save hook was disabled because of exception: %s' % e)
height = models.PositiveIntegerField() def get_url(self): return '/images/db/' + self.path def get_path(self, create=False): full_path = os.path.join(settings.CIA_DATA_PATH, 'db', 'images' , self.path) if create: directory = os.path.dirname(full_path) try: os.makedirs(directory) except OSError: pass return full_path def update_image_size(self): self.width, self.height = ImageInstance.objects.magick.get_image_size(self.get_path()) def to_html(self): return '<img src="%s" width="%d" height="%d" />' % ( self.get_url(), self.width, self.height) def remove_deleted_instance(instance): if instance.delete_file: try: os.unlink(instance.get_path()) except OSError: pass dispatcher.connect(remove_deleted_instance, signal=signals.post_delete, sender=ImageInstance)
def create_superuser(app, created_models, verbosity, **kwargs): from django.contrib.auth.models import User from django.core.management import call_command if User in created_models and kwargs.get('interactive', True): msg = "\nYou just installed Django's auth system, which means you don't have " \ "any superusers defined.\nWould you like to create one now? (yes/no): " confirm = raw_input(msg) while 1: if confirm not in ('yes', 'no'): confirm = raw_input('Please enter either "yes" or "no": ') continue if confirm == 'yes': call_command("createsuperuser", interactive=True) break if 'create_permissions' not in [ i.__name__ for i in dispatcher.getAllReceivers(signal=signals.post_syncdb) ]: dispatcher.connect(create_permissions, signal=signals.post_syncdb) if 'create_superuser' not in [ i.__name__ for i in dispatcher.getAllReceivers(signal=signals.post_syncdb, sender=auth_app) ]: dispatcher.connect(create_superuser, sender=auth_app, signal=signals.post_syncdb)
class Admin: list_display = ('type',) class Meta: verbose_name_plural = "Element Categories" def __str__(self): return self.type # ------------------------------------------------------------------------------ # monkey patched model methods # ------------------------------------------------------------------------------ Render.getRender = GetRender(Render) Shot.getShot = GetShot(Shot) User.getUser = GetUser(User) Event.getEvent = GetEvent(Event) Project.getProject = GetProject(Project) # ------------------------------------------------------------------------------ # signal handler processing # ------------------------------------------------------------------------------ h = Handler() dispatcher.connect(h.handle_post_init, signal=signals.post_init) dispatcher.connect(h.handle_pre_save, signal=signals.pre_save) dispatcher.connect(h.handle_post_save, signal=signals.post_save) dispatcher.connect(h.handle_pre_delete, signal=signals.pre_delete) def getHandler(): return h
from django.dispatch import dispatcher from django.db.models.signals import post_save from snapshots.models import Snapshot from snapshots.signals import generate_image dispatcher.connect(generate_image, signal=post_save, sender=Snapshot)
ct = ContentType.objects.get(app_label=opts.app_label, model=opts.object_name.lower()) content_types.remove(ct) except ContentType.DoesNotExist: ct = ContentType(name=smart_unicode(opts.verbose_name_raw), app_label=opts.app_label, model=opts.object_name.lower()) ct.save() if verbosity >= 2: print "Adding content type '%s | %s'" % (ct.app_label, ct.model) # The presence of any remaining content types means the supplied app has an # undefined model and can safely be removed, which cascades to also remove # related permissions. for ct in content_types: if verbosity >= 2: print "Deleting stale content type '%s | %s'" % (ct.app_label, ct.model) ct.delete() def update_all_contenttypes(verbosity=2): for app in get_apps(): update_contenttypes(app, None, verbosity) dispatcher.connect(update_contenttypes, signal=signals.post_syncdb) if __name__ == "__main__": update_all_contenttypes()
location = models.CharField(max_length=50, blank=True, null=True) name = models.CharField(max_length=50, blank=True, null=True) thumbnail_url = models.URLField() url = models.URLField(blank=True, null=True) friends = models.ManyToManyField('TwitterUser', related_name='friends_user_set', blank=True, null=True) followers = models.ManyToManyField('TwitterUser', related_name='followers_user_set', blank=True, null=True) def numFriends(self): return self.friends.count() def numFollowers(self): return self.followers.count() def __unicode__(self): return self.screen_name class Admin: list_display = ('screen_name', 'name', 'location', 'numFriends', 'numFollowers') class TweetModerator(CommentModerator): akismet = settings.COMMENTS_AKISMET auto_moderate_field = 'pub_time' moderate_after = settings.COMMENTS_MODERATE_AFTER email_notification = settings.COMMENTS_EMAIL enable_field = settings.COMMENTS_ENABLE_FIELD moderator.register(Tweet, TweetModerator) dispatcher.connect(create_tumblelog_item, sender=Tweet, signal=signals.post_save) dispatcher.connect(kill_tumblelog_item, sender=Tweet, signal=signals.post_delete)
def contribute_to_class(self, cls, name): super(ImageWithThumbnailField, self).contribute_to_class(cls, name) dispatcher.connect(_delete, signals.post_delete, sender=cls) dispatcher.connect(self._save, signals.pre_save, sender=cls)
if not app_models: return for klass in app_models: opts = klass._meta try: ct = ContentType.objects.get(app_label=opts.app_label, model=opts.object_name.lower()) content_types.remove(ct) except ContentType.DoesNotExist: ct = ContentType(name=smart_unicode(opts.verbose_name_raw), app_label=opts.app_label, model=opts.object_name.lower()) ct.save() if verbosity >= 2: print "Adding content type '%s | %s'" % (ct.app_label, ct.model) # The presence of any remaining content types means the supplied app has an # undefined model and can safely be removed, which cascades to also remove # related permissions. for ct in content_types: if verbosity >= 2: print "Deleting stale content type '%s | %s'" % (ct.app_label, ct.model) ct.delete() def update_all_contenttypes(verbosity=2): for app in get_apps(): update_contenttypes(app, None, verbosity) dispatcher.connect(update_contenttypes, signal=signals.post_syncdb) if __name__ == "__main__": update_all_contenttypes()
# Create your models here. # Place an otherwise blank app in settings.INSTALLED_APPS # and add the following into the app's models.py: from django.db.models import signals from django.dispatch import dispatcher from django.contrib.auth import models as auth_app import new, crypt, random, string from django.utils.encoding import smart_str def set_password_crypt(self, raw_password): algo = 'crypt' saltchars = string.ascii_letters + string.digits + './' salt = ''.join(random.choice(saltchars) for i in range(2)) hsh = crypt.crypt(smart_str(raw_password), salt) self.password = '******' % (algo, salt, hsh) def replace_set_password(instance=None): instance.set_password = new.instancemethod( set_password_crypt, instance, instance.__class__) dispatcher.connect(replace_set_password, sender=auth_app.User, signal=signals.post_init)
elif self.book.textformat == 'markdown': import markdown self.html = markdown.markdown(self.content) super(Chapter, self).save() def post_save_chapter(sender, instance, signal, *args, **kwargs): try: book = Book.objects.get(id=instance.book.id) except Book.DoesNotExist: return # book.modifydate = datetime.datetime.now() book.save() dispatcher.connect(post_save_chapter, signal=signals.post_save, sender=Chapter) class CommentInfo(models.Model): chapter = models.ForeignKey(Chapter) comment_num = models.CharField(maxlength=20) count = models.IntegerField(default=0) C_STATUS = ((0, 'None'), (1, 'Good'), (2, 'Bad')) class Comment(models.Model): book = models.ForeignKey(Book) chapter = models.ForeignKey(Chapter) comment_num = models.CharField(maxlength=20)
ordering = [ 'id', ] def save(self): if not self.id: self.date = datetime.now() super(EventFile, self).save() def add_user_call_back(signal, sender, instance, **kwags): """ >>> from django.contrib.auth.models import User >>> u = User.objects.create_user('testuser', '*****@*****.**', password='******') >>> profile = u.get_profile() >>> profile.nickname u'testuser' """ try: instance.get_profile() except EventProfile.DoesNotExist: profile = EventProfile() profile.user = instance profile.nickname = instance.username profile.save() dispatcher.connect(receiver=add_user_call_back, signal=signals.post_save, sender=User)
self.conn.start() self.conn.connect() def disconnect(self): self.conn.stop() CACHE_DELETER = CacheDeleter() if AMQ_HOST: try: import stomp import socket # check connection to defined AMQ s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((AMQ_HOST, AMQ_PORT)) s.close() # connection checked, connect CACHE_DELETER CACHE_DELETER.connect([(AMQ_HOST, AMQ_PORT)]) # start listening for any model dispatcher.connect(CACHE_DELETER.propagate_signal, signal=signals.post_save) dispatcher.connect(CACHE_DELETER.propagate_signal, signal=signals.post_delete) log.debug('Start listening for any model') except: log.warning('ActiveMQ not running')
from django.dispatch import dispatcher from django.db.models import signals from django.db.models.fields import FieldDoesNotExist def ensure_default_manager(sender): cls = sender if not hasattr(cls, '_default_manager'): # Create the default manager, if needed. try: cls._meta.get_field('objects') raise ValueError, "Model %s must specify a custom Manager, because it has a field named 'objects'" % cls.__name__ except FieldDoesNotExist: pass cls.add_to_class('objects', Manager()) dispatcher.connect(ensure_default_manager, signal=signals.class_prepared) class Manager(object): # Tracks each time a Manager instance is created. Used to retain order. creation_counter = 0 def __init__(self): super(Manager, self).__init__() # Increase the creation counter, and save our local copy. self.creation_counter = Manager.creation_counter Manager.creation_counter += 1 self.model = None def contribute_to_class(self, model, name): # TODO: Use weakref because of possible memory leak / circular reference. self.model = model
""" Copied over from django.contrib.auth.management """ from django.dispatch import dispatcher from django.db.models import get_models, signals def _get_permission_codename(action, opts): return u'%s_%s' % (action, opts.object_name.lower()) def _get_all_permissions(opts): "Returns (codename, name) for all permissions in the given opts." return [ (_get_permission_codename('view', opts), u'Can view %s' % (opts.verbose_name_raw)), ] def create_permissions(app, created_models, verbosity): from django.contrib.contenttypes.models import ContentType from django.contrib.auth.models import Permission app_models = get_models(app) if not app_models: return for klass in app_models: ctype = ContentType.objects.get_for_model(klass) for codename, name in _get_all_permissions(klass._meta): p, created = Permission.objects.get_or_create(codename=codename, content_type__pk=ctype.id, defaults={'name': name, 'content_type': ctype}) if created and verbosity >= 2: print "Adding permission '%s'" % p dispatcher.connect(create_permissions, signal=signals.post_syncdb)
ctype = ContentType.objects.get_for_model(klass) for codename, name in _get_all_permissions(klass._meta): p, created = Permission.objects.get_or_create( codename=codename, content_type__pk=ctype.id, defaults={"name": name, "content_type": ctype} ) if created and verbosity >= 2: print "Adding permission '%s'" % p def create_superuser(app, created_models, verbosity, **kwargs): from django.contrib.auth.models import User from django.contrib.auth.create_superuser import createsuperuser as do_create if User in created_models and kwargs.get("interactive", True): msg = ( "\nYou just installed Django's auth system, which means you don't have " "any superusers defined.\nWould you like to create one now? (yes/no): " ) confirm = raw_input(msg) while 1: if confirm not in ("yes", "no"): confirm = raw_input('Please enter either "yes" or "no": ') continue if confirm == "yes": do_create() break dispatcher.connect(create_permissions, signal=signals.post_syncdb) dispatcher.connect(create_superuser, sender=auth_app, signal=signals.post_syncdb)
field.do_related_class(model, cls) else: key = (app_label, model_name) value = (cls, field) pending_lookups.setdefault(key, []).append(value) def do_pending_lookups(sender): """ Handle any pending relations to the sending model. Sent from class_prepared. """ key = (sender._meta.app_label, sender.__name__) for cls, field in pending_lookups.pop(key, []): field.rel.to = sender field.do_related_class(sender, cls) dispatcher.connect(do_pending_lookups, signal=signals.class_prepared) def manipulator_valid_rel_key(f, self, field_data, all_data): "Validates that the value is a valid foreign key" klass = f.rel.to try: klass._default_manager.get(**{f.rel.field_name: field_data}) except klass.DoesNotExist: raise validators.ValidationError, _("Please enter a valid %s.") % f.verbose_name #HACK class RelatedField(object): def contribute_to_class(self, cls, name): sup = super(RelatedField, self) # Add an accessor to allow easy determination of the related query path for this field
""" Creates the default Site object. """ from django.dispatch import dispatcher from django.db.models import signals from django.contrib.sites.models import Site from django.contrib.sites import models as site_app def create_default_site(app, created_models, verbosity): if Site in created_models: if verbosity >= 2: print "Creating example.com Site object" s = Site(domain="example.com", name="example.com") s.save() dispatcher.connect(create_default_site, sender=site_app, signal=signals.post_syncdb)
from django import oldforms from django.core import validators from django.db.models.fields import FileField, AutoField from django.dispatch import dispatcher from django.db.models import signals from django.utils.functional import curry from django.utils.datastructures import DotExpandedDict from django.utils.text import capfirst import types def add_manipulators(sender): cls = sender cls.add_to_class('AddManipulator', AutomaticAddManipulator) cls.add_to_class('ChangeManipulator', AutomaticChangeManipulator) dispatcher.connect(add_manipulators, signal=signals.class_prepared) class ManipulatorDescriptor(object): # This class provides the functionality that makes the default model # manipulators (AddManipulator and ChangeManipulator) available via the # model class. def __init__(self, name, base): self.man = None # Cache of the manipulator class. self.name = name self.base = base def __get__(self, instance, model=None): if instance != None: raise AttributeError, "Manipulator cannot be accessed via instance" else: if not self.man:
def register(model, parent_attr='parent', left_attr='lft', right_attr='rght', tree_id_attr='tree_id', level_attr='level', tree_manager_attr='tree', order_insertion_by=None): """ Sets the given model class up for Modified Preorder Tree Traversal. """ if model in registry: raise AlreadyRegistered( _('The model %s has already been registered.') % model.__name__) registry.append(model) # Add tree options to the model's Options opts = model._meta opts.parent_attr = parent_attr opts.right_attr = right_attr opts.left_attr = left_attr opts.tree_id_attr = tree_id_attr opts.level_attr = level_attr opts.tree_manager_attr = tree_manager_attr opts.order_insertion_by = order_insertion_by opts.get_field(left_attr).null = True opts.get_field(left_attr).blank = True # Add tree fields if they do not exist for attr in [left_attr, right_attr, tree_id_attr, level_attr]: try: opts.get_field(attr) except FieldDoesNotExist: PositiveIntegerField(db_index=True, editable=False).contribute_to_class( model, attr) # Add tree methods for model instances setattr(model, 'get_ancestors', models.get_ancestors) setattr(model, 'get_children', models.get_children) setattr(model, 'get_descendants', models.get_descendants) setattr(model, 'get_descendant_count', models.get_descendant_count) setattr(model, 'get_next_sibling', models.get_next_sibling) setattr(model, 'get_previous_sibling', models.get_previous_sibling) setattr(model, 'get_root', models.get_root) setattr(model, 'get_siblings', models.get_siblings) setattr(model, 'insert_at', models.insert_at) setattr(model, 'is_child_node', models.is_child_node) setattr(model, 'is_leaf_node', models.is_leaf_node) setattr(model, 'is_root_node', models.is_root_node) setattr(model, 'move_to', models.move_to) # Add a custom tree manager TreeManager(parent_attr, left_attr, right_attr, tree_id_attr, level_attr).contribute_to_class(model, tree_manager_attr) setattr(model, '_tree_manager', getattr(model, tree_manager_attr)) # Set up signal receivers to manage the tree when instances of the # model are about to be created, have their parent changed or be # deleted. dispatcher.connect(pre_save, signal=model_signals.pre_save, sender=model) dispatcher.connect(pre_delete, signal=model_signals.pre_delete, sender=model)
return (urlparse.urljoin( settings.MEDIA_URL, os.path.join(AVATARS_CACHE_DIR, hash + '.png')), dict(width=cache.actual_width, height=cache.actual_height)) except Exception: logger.exception("can't save avatar cache") return (None, dict(width=0, height=0)) def comment_postsave(sender, instance): hash = gen_hash(instance.author_email, instance.author_site) try: cache = CacheState.objects.get(hash=hash) cache.expire_after = datetime.datetime.today() cache.save() except CacheState.DoesNotExist: pass if __name__ == 'avatars.models': from django.dispatch import dispatcher from django.db.models import signals try: from lfcomments.models import Comment dispatcher.connect(comment_postsave, signal=signals.post_save, sender=Comment) except Exception, e: logging.warning( 'post_save hook was disabled because of exception: %s' % e)
get_introspection_module = lambda: __import__( 'django.db.backends.%s.introspection' % settings.DATABASE_ENGINE, {}, {}, ['']) get_creation_module = lambda: __import__( 'django.db.backends.%s.creation' % settings.DATABASE_ENGINE, {}, {}, ['']) runshell = lambda: __import__( 'django.db.backends.%s.client' % settings.DATABASE_ENGINE, {}, {}, [''] ).runshell() connection = backend.DatabaseWrapper(**settings.DATABASE_OPTIONS) DatabaseError = backend.DatabaseError # Register an event that closes the database connection # when a Django request is finished. dispatcher.connect(connection.close, signal=signals.request_finished) # Register an event that resets connection.queries # when a Django request is started. def reset_queries(): connection.queries = [] dispatcher.connect(reset_queries, signal=signals.request_started) # Register an event that rolls back the connection # when a Django request has an exception. def _rollback_on_exception(): from django.db import transaction
from django.db.models import signals from django.utils.functional import curry from django.utils.datastructures import DotExpandedDict from django.utils.text import capfirst from django.utils.encoding import smart_str from django.utils.translation import ugettext as _ from django.utils import datetime_safe def add_manipulators(sender): cls = sender cls.add_to_class('AddManipulator', AutomaticAddManipulator) cls.add_to_class('ChangeManipulator', AutomaticChangeManipulator) dispatcher.connect(add_manipulators, signal=signals.class_prepared) class ManipulatorDescriptor(object): # This class provides the functionality that makes the default model # manipulators (AddManipulator and ChangeManipulator) available via the # model class. def __init__(self, name, base): self.man = None # Cache of the manipulator class. self.name = name self.base = base def __get__(self, instance, model=None): if instance != None: raise AttributeError, "Manipulator cannot be accessed via instance" else:
field.do_related_class(model, cls) else: key = (app_label, model_name) value = (cls, field) pending_lookups.setdefault(key, []).append(value) def do_pending_lookups(sender): """ Handle any pending relations to the sending model. Sent from class_prepared. """ key = (sender._meta.app_label, sender.__name__) for cls, field in pending_lookups.pop(key, []): field.rel.to = sender field.do_related_class(sender, cls) dispatcher.connect(do_pending_lookups, signal=signals.class_prepared) def manipulator_valid_rel_key(f, self, field_data, all_data): "Validates that the value is a valid foreign key" klass = f.rel.to try: klass._default_manager.get(**{f.rel.field_name: field_data}) except klass.DoesNotExist: raise validators.ValidationError, _("Please enter a valid %s.") % f.verbose_name #HACK class RelatedField(object): def contribute_to_class(self, cls, name): sup = super(RelatedField, self) # Add an accessor to allow easy determination of the related query path for this field
) else: raise # If there's some other error, this must be an error in Django itself. get_introspection_module = lambda: __import__( "django.db.backends.%s.introspection" % settings.DATABASE_ENGINE, {}, {}, [""] ) get_creation_module = lambda: __import__("django.db.backends.%s.creation" % settings.DATABASE_ENGINE, {}, {}, [""]) runshell = lambda: __import__("django.db.backends.%s.client" % settings.DATABASE_ENGINE, {}, {}, [""]).runshell() connection = backend.DatabaseWrapper(**settings.DATABASE_OPTIONS) DatabaseError = backend.DatabaseError # Register an event that closes the database connection # when a Django request is finished. dispatcher.connect(connection.close, signal=signals.request_finished) # Register an event that resets connection.queries # when a Django request is started. def reset_queries(): connection.queries = [] dispatcher.connect(reset_queries, signal=signals.request_started) # Register an event that rolls back the connection # when a Django request has an exception. def _rollback_on_exception(): from django.db import transaction transaction.rollback_unless_managed()
self.conn = stomp.Connection(*args, **kwargs) self.conn.start() self.conn.connect() def disconnect(self): self.conn.stop() CACHE_DELETER = CacheDeleter() if AMQ_HOST: try: import stomp import socket # check connection to defined AMQ s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((AMQ_HOST, AMQ_PORT)) s.close() # connection checked, connect CACHE_DELETER CACHE_DELETER.connect([(AMQ_HOST, AMQ_PORT)]) # start listening for any model dispatcher.connect(CACHE_DELETER.propagate_signal, signal=signals.post_save) dispatcher.connect(CACHE_DELETER.propagate_signal, signal=signals.post_delete) log.debug('Start listening for any model') except: log.warning('ActiveMQ not running')