Пример #1
0
def synchronize_extractor_task(sender, *args, **kwargs):
    pre_init.disconnect(synchronize_extractor_task, sender=sender)

    doc = sender.__dict__.get('__doc__')
    if doc.startswith(sender.__name__):
        keys = doc[len(sender.__name__) + 1:-1].split(', ')
        values = kwargs.get('args')

        if len(keys) == len(values):
            kvp = dict((k, values[i]) for i, k in enumerate(keys))

            try:
                instance = AsyncExtractorTask.objects.get(uuid=kvp['uuid'])
            except AsyncExtractorTask.DoesNotExist:
                pass
            else:
                if instance.success is None:
                    url = instance.details['possible_requests']['status'][
                        'url']
                    r = requests.get(url)

                    if r.status_code == 200:
                        details = instance.details
                        details.update(r.json())

                        instance.success = {
                            'SUCCESS': True,
                            'FAILURE': False,
                        }.get(details['status'], None)

                        instance.details = details
                        if instance.success is False:
                            instance.stop_datetime = timezone.now()
                        else:
                            instance.stop_datetime = details.get(
                                'end_datetime')

                        instance.start_datetime = \
                            details.get('start_datetime') or instance.stop_datetime

                        instance.save()

                        if instance.success is True:
                            send_extraction_successfully_mail(
                                instance.user, instance)
                        elif instance.success is False:
                            send_extraction_failure_mail(
                                instance.user, instance)

    pre_init.connect(synchronize_extractor_task, sender=sender)
Пример #2
0
    def contribute_to_class(self, cls, name):
        super(PolymorphicChildManager, self).contribute_to_class(cls, name)
        polymorphic_on = self._polymorphic_manager.polymorphic_on
        identity = self._identity
        id2model = self._polymorphic_manager._id2model
        if identity in id2model:
            raise ImproperlyConfigured(
                'More than one subclasses with the same identity (%s.%s=%s)' %
                (self._polymorphic_manager.model.__name__, polymorphic_on,
                 identity))
        id2model[identity] = cls
        if self._autoinit:

            def preset_identity(sender, args, kwargs, **_):
                if polymorphic_on not in kwargs:
                    kwargs[polymorphic_on] = identity

            pre_init.connect(preset_identity, sender=cls, weak=False)
Пример #3
0
from django.db.models.signals import pre_delete, post_delete
from django.db.models.signals import m2m_changed
from django.db.models.signals import pre_migrate, post_migrate

from django.test.signals import setting_changed
from django.test.signals import template_rendered

from django.db.backends.signals import connection_created


def f1(sender, **kwargs):
    print("execute ------f1 signal----------")
    # print(sender, kwargs)


pre_init.connect(f1)



import django.dispatch
custom_signal_name = django.dispatch.Signal(providing_args=["aaa", "bbb"])



# def callback(sender, **kwargs):
#     print("callback")
#     print(sender, kwargs)
#
#
# pizza_done.connect(callback)
Пример #4
0
from django.db.models import Model
from django.db.models.signals import class_prepared, pre_init

from .utils import normalize_table


def transform_db_table(sender: Model, **kwargs):
    from .settings import db_settings

    should_transform = (db_settings.ENABLE_TRANSFORM_DB_TABLE
                        and db_settings.DEFAULT_DB_TABLE_PATTERN)

    if should_transform:
        normalized_name = normalize_table(
            sender._meta.db_table,
            format=db_settings.DEFAULT_DB_TABLE_PATTERN,
            exclude=db_settings.IGNORE_DB_TABLE_PATTERNS,
        )

        sender._meta.db_table = normalized_name


pre_init.connect(transform_db_table)
class_prepared.connect(transform_db_table)
Пример #5
0
from django.db.models.signals import pre_init
from courant.core.countthis.models import Statistic
from django.contrib.contenttypes.models import ContentType


def add_statistics(sender, *args, **kwargs):
    sender.add_to_class('statistics',
                        lambda self:
                            Statistic.objects.get(
                                content_type=
                                    ContentType.objects.get_for_model(self),
                                object_id=self.pk))

pre_init.connect(add_statistics)
Пример #6
0
from django.conf import settings
from django.db.models.signals import class_prepared, pre_init


def add_db_prefix(sender, **kwargs):
    prefix = getattr(settings, "DB_PREFIX", None)
    if prefix and not sender._meta.db_table.startswith(prefix) and getattr(
            sender, 'use_db_prefix', True):
        sender._meta.db_table = prefix + sender._meta.db_table


pre_init.connect(add_db_prefix)
class_prepared.connect(add_db_prefix)
Пример #7
0
    creator = models.ForeignKey(CustomUser)
    reply = models.ManyToManyField(Reply)


##ADMIN


class PostAdmin(admin.ModelAdmin):
    list_display = ["creator", "created"]
    list_filter = ["creator"]


class ReplyAdmin(admin.ModelAdmin):
    list_display = ["creator", "created"]
    list_filter = ["creator"]


admin.site.register(Post, PostAdmin)
admin.site.register(Reply, ReplyAdmin)



def Post_creado(sender,args, **kwargs):
#Cuando el usuario con ID=2 crea un post este se almacena como post del Admin
    dic=kwargs.__getitem__('kwargs')
    if dic.get('creator' ) == CustomUser.objects.get(id=2):
        dic.__setitem__('creator', CustomUser.objects.get(id=1))


pre_init.connect(Post_creado, sender=Post)
Пример #8
0
    if "auto_set_key_name" in kwargs:
        if sender.kind() in auto_set_key_name_table and "key_name" not in kwargs:
            fields = auto_set_key_name_table[sender.kind()]
            items = []
            
            for f in fields:
                
                if not hasattr(sender,f): # It is not a property. It is a keyword
                    items.append(f)
                    continue
                    
                prop = getattr(sender,f)
                value = kwargs[f]
                if isinstance(prop,db.ReferenceProperty):
                    if isinstance(value,db.Key):
				        items.append(value.id_or_name())
                    else:
                        items.append(value.key().id_or_name())
                        
                elif isinstance(prop,MLStringProperty):
                    items.append(MLStringProperty.to_key_name(value))
                else:
                    items.append(value)
                    
            key_name = "-".join(items)
            kwargs["key_name"] = next_key_name(sender,key_name)
        
        del kwargs["auto_set_key_name"]

pre_init.connect(auto_set_key_name)
Пример #9
0
        for mturk_assignment in assignments:
            assert mturk_assignment.HITId == self.mturk_id
            djurk_assignment, _ = Assignment.objects.get_or_create(
                mturk_id=mturk_assignment.AssignmentId, hit=self)
            djurk_assignment.update(mturk_assignment, hit=self)
        if update_all and int(assignments.PageNumber) *\
                            page_size < int(assignments.TotalNumResults):
            self.update_assignments(page_number + 1, page_size, update_all)

    class Meta:
        verbose_name = "HIT"
        verbose_name_plural = "HITs"

    def __unicode__(self):
        return u"HIT: %s" % self.mturk_id
pre_init.connect(init_connection_callback, sender=HIT)


class Assignment(models.Model):
    """An Amazon Mechanical Turk Assignment as a Django Model"""

    (_SUBMITTED, _APPROVED, _REJECTED) = ("Submitted", "Approved", "Rejected")
    (SUBMITTED, APPROVED, REJECTED) = ("S", "A", "R")

    STATUS_CHOICES = (
            (SUBMITTED, _SUBMITTED),
            (APPROVED, _APPROVED),
            (REJECTED, _REJECTED),
    )
    # Convenience lookup dictionaries for the above lists
    reverse_status_lookup = dict((v, k) for k, v in STATUS_CHOICES)
Пример #10
0
            djurk_assignment = Assignment.objects.get_or_create(
                mturk_id=mturk_assignment.AssignmentId, hit=self)[0]
            djurk_assignment.update(mturk_assignment, hit=self)
        if update_all and int(assignments.PageNumber) *\
                            page_size < int(assignments.TotalNumResults):
            self.update_assignments(page_number + 1, page_size, update_all)

    class Meta:
        verbose_name = "HIT"
        verbose_name_plural = "HITs"

    def __unicode__(self):
        return u"HIT: %s" % self.mturk_id


pre_init.connect(init_connection_callback, sender=HIT)


class Assignment(models.Model):
    """An Amazon Mechanical Turk Assignment as a Django Model"""

    (_SUBMITTED, _APPROVED, _REJECTED) = ("Submitted", "Approved", "Rejected")
    (SUBMITTED, APPROVED, REJECTED) = ("S", "A", "R")

    STATUS_CHOICES = (
        (SUBMITTED, _SUBMITTED),
        (APPROVED, _APPROVED),
        (REJECTED, _REJECTED),
    )
    # Convenience lookup dictionaries for the above lists
    reverse_status_lookup = dict((v, k) for k, v in STATUS_CHOICES)
Пример #11
0
 def ready(self):
     MyModel = self.get_model('DiscipleTeacher')
     pre_init.connect(event_handler,
                      sender=MyModel,
                      dispatch_uid='limit_on_number_recruit')
Пример #12
0
		attributes['debit_derniere_soiree_reg'] = attributes['debit_derniere_soiree']
		del attributes['debit_derniere_soiree']		
	if 'debit_initial' in attributes:
		attributes['debit_initial_reg'] = attributes['debit_initial']
		del attributes['debit_initial']
	if 'total_depenses_corrige' in attributes:
		attributes['total_depenses_corrige_reg'] = attributes['total_depenses_corrige']
		del attributes['total_depenses_corrige']
	if 'recette_billets_vendus' in attributes:
		attributes['total_recettes'] = attributes['recette_billets_vendus']
		del attributes['recette_billets_vendus']
	if 'anecdote' in attributes:
		del attributes['anecdote']
	kwargs['kwargs'] = attributes
		
pre_init.connect(pre_init_budget, BudgetSoiree)

class Abonnement(models.Model):
	debut = models.DateField()
	fin = models.DateField()
	tarif = models.IntegerField()
	abonne = models.ForeignKey('Personne')

	def __unicode__(self):
		return u'Abonnement du {0.debut!s} au {0.fin!s} pour la somme de {0.montant!s}d'.format(self)


# récapitualif "hors compte", non associé à une transaction	
class Recapitulatif(models.Model):
	T_RECAPITULATIF = (
	    (0, 'hebdomadaire'),
Пример #13
0
    templates = []

    for extension in request.extension:
        for template in arguments[0]:
            if template:
                templates.append("".join([template, ".", extension]))

    arguments[0] = templates

    return render_to_response(*arguments, **kwargs)


# Make common_tags available everywhere
for library in settings.TEMPLATE_TAGS:
    add_to_builtins(library)

# Add a .type method to every object, so you can ask it what type it is from templates
def add_type(sender, *args, **kwargs):
    sender.add_to_class("type", lambda self: self._meta.verbose_name)


pre_init.connect(add_type)

# register Tag model with gettag, since Tag model can't be modified directly (svn:external)
gettag.register(
    Tag, name_field="tag__name", with_func=Tag.objects.usage_for_queryset, in_func=TaggedItem.objects.get_by_model
)

# register ContentType with gettag
gettag.register(ContentType, name_field="model")
Пример #14
0
    @return:
    """
    act = kwargs['instance']
    act.acthome = os.path.join(act.venue.VENUE_ROOT, 'acts', act.actname)
    act.uwsgi_ip = None
    act.uwsgi_port = None
    act.uwsgifile = os.path.join(act.acthome, 'uwsgi.ini')
    if not os.path.exists(act.acthome):
        print 'Act %s does not exist in venue %s' % (act.venue.VENUE_NAME, act.actname)
        raise
    return

def postpopulate_act(sender, **kwargs):
    """
    Populate an act instance with some parameters and methods
    @param sender:
    @param kwargs:
    @return:
    """
    act = kwargs['instance']
    act.get_settings()
    act.uwsgi_linker()
    act.uwsgi_log = act.get_uwsgi_log()
    return

#Execute upon initiation of Venue object.
#Populate some content for the venue
pre_init.connect(prevalidate_act, sender=Act)
post_init.connect(postpopulate_act, sender=Act)
pre_init.connect(prevalidate_venue, sender=Venue)
post_init.connect(postpopulate_venue, sender=Venue)
Пример #15
0
 def ready(self):
     pre_init.connect(add_db_prefix)
     class_prepared.connect(add_db_prefix)
     logger.info("CONNECTED PREFIX SIGNALS")
Пример #16
0
from django.core.signals import request_finished
from django.core.signals import request_started
from django.core.signals import got_request_exception

from django.db.models.signals import class_prepared
from django.db.models.signals import pre_init, post_init
from django.db.models.signals import pre_save, post_save
from django.db.models.signals import pre_delete, post_delete
from django.db.models.signals import m2m_changed
from django.db.models.signals import pre_migrate, post_migrate

from django.test.signals import setting_changed
from django.test.signals import template_rendered

from django.db.backends.signals import connection_created


def callback(sender, **kwargs):
    print("xxoo_callback")
    print(sender,kwargs)

pre_init.connect(callback) #加载pre_init
Пример #17
0
#!/usr/local/bin/env python3
# -*- coding:utf-8 -*-
# __author__:"Howard"

from django.core.signals import request_finished
from django.core.signals import request_started
from django.core.signals import got_request_exception

from django.db.models.signals import class_prepared
from django.db.models.signals import pre_init, post_init
from django.db.models.signals import pre_save, post_save
from django.db.models.signals import pre_delete, post_delete
from django.db.models.signals import m2m_changed
from django.db.models.signals import pre_migrate, post_migrate

from django.test.signals import setting_changed
from django.test.signals import template_rendered

from django.db.backends.signals import connection_created


def callback(sender, **kwargs):
    print("xxoo_callback")
    print(sender,kwargs)

pre_init.connect(callback)
from django.test.signals import setting_changed
from django.test.signals import template_rendered

from django.db.backends.signals import connection_created


# region 注册方式1
# 接受信号函数
def callback(sender, **kwargs):
    # print("pre_init_callback")
    # print(sender, kwargs)
    pass


# 注册接受数据库对象构造函数触发信号
pre_init.connect(callback)
# endregion

# region 注册方式2
from django.core.signals import request_finished
from django.dispatch import receiver


@receiver(request_finished)
def my_callback(sender, **kwargs):
    # print("Request finished!")
    pass


# endregion
Пример #19
0
from django.conf import settings
from django.db.models.signals import class_prepared, pre_init


def add_db_prefix(sender, **kwargs):
    prefix = getattr(settings, "DB_PREFIX", None)
    if prefix and not sender._meta.db_table.startswith(prefix):
        sender._meta.db_table = prefix + sender._meta.db_table


pre_init.connect(add_db_prefix)
class_prepared.connect(add_db_prefix)