django.utils.functional.curry

Here are the examples of the python api django.utils.functional.curry taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

116 Examples 7

Example 51

Project: ella Source File: newman_admin.py
    def get_mass_upload_context(self, request):
        model = self.model
        opts = model._meta
        self.register_newman_variables(request)

        # To enable admin-specific fields, we need to run the form class
        # through modelform_factory using curry
        FormClass = modelform_factory(Photo, form=MassUploadForm,
                                      fields=flatten_fieldsets(
                                          self.mass_upload_fieldsets),
                                      formfield_callback=curry(
                                          self.formfield_for_dbfield,
                                          request=request)
        )

        context = {}
        if request.method == 'POST':
            error_dict = {}
            # Unfortunately, FLASH uploader sends array data in weird format
            # so that Django doesn't recognize it as array of values, but
            # as one string with commas inside. The only way to expect it
            # and preprocess the values by ourselves.
            data = dict((key, val) for key, val in request.POST.items())
            form = FormClass(data, request.FILES)

            if form.is_valid():
                # To prevent newman from handling our field by common flash editor
                # we need to use a different mechanism
                new_object = form.save(commit=False)
                new_object.image = form.cleaned_data['image_file']
                new_object.save()
                form.save_m2m()
                context.update({'object': new_object})
            else:
                for e in form.errors:
                    error_dict[u"id_%s" % e] = [u"%s" % ee for ee in
                                                form.errors[e]]
                context.update({'error_dict': error_dict})
        else:
            form = FormClass()

        adminForm = helpers.AdminForm(form, list(self.mass_upload_fieldsets), self.prepopulated_fields)
        massUploadForm = helpers.AdminForm(form, list(self.mass_upload2_fieldsets), self.prepopulated_fields)
        media = self.media + adminForm.media

        context.update({
            'title': _('Mass upload'),
            'adminform': adminForm,
            'mass_upload2_form': massUploadForm,
            'is_popup': request.REQUEST.has_key('_popup'),
            'show_delete': False,
            'media': media,
            'inline_admin_formsets': [],
            'errors': helpers.AdminErrorList(form, ()),
            'root_path': self.admin_site.root_path,
            'app_label': opts.app_label,
            'opts': opts,
            'has_change_permission': self.has_change_permission(request,
                                                                None),
            'raw_form': form
        })
        return context

Example 52

Project: huDjango Source File: scalingimagefield.py
Function: init
    def __init__(self, field, obj):
        self.field = field
        self.parent_obj = obj
        self.original_image = getattr(self.parent_obj, self.field.attname)
        self.original_image_path = os.path.join(settings.MEDIA_ROOT, str(self.original_image))
        self.mangled_name = str(self.original_image) # md5.new('sehkr1tt-%s-%r-%r' % (str(self.original_image), time.time(), id(self))).hexdigest()
        self.scaled_image_base = os.path.join(settings.MEDIA_ROOT, ',', self.mangled_name)
        self.broken_image = None

        # imageid is used for webstorage
        self.imageid = None

        # if broken.gif exists we send that if there are any problems during scaling
        if not os.path.exists(self.original_image_path):
            # check if we are using web based storage
            self.imageid = str(self.original_image)
            if self.imageid in huimages._setup_couchdb():
                self.original_image_path = huimages.imageurl(self.imageid)
            else:
                self.broken_image = os.path.join(settings.MEDIA_ROOT, 'broken.gif') 

        for size in _sizes:
            setattr(self, '%s_path' % (size), curry(self.scaled_filename, size))
            setattr(self, '%s' % (size), curry(self.scaled_url, size))
            setattr(self, '%s_dimensions' % (size), curry(self.scaled_dimensions, size))
            setattr(self, '%s_tag' % (size), curry(self.scaled_tag, size))

Example 53

Project: canvas Source File: template.py
    def context_tag(self, func):
        params, xx, xxx, defaults = getargspec(func)

        class ContextNode(django_template.Node):
            def __init__(self, vars_to_resolve):
                self.vars_to_resolve = map(django_template.Variable, vars_to_resolve)

            def render(self, context):
                resolved_vars = [var.resolve(context) for var in self.vars_to_resolve]
                return func(context, *resolved_vars)

        compile_func = curry(django_template.generic_tag_compiler,
                             params[1:],
                             defaults[1:] if defaults else None,
                             getattr(func, "_decorated_function", func).__name__,
                             ContextNode)

        compile_func.__doc__ = func.__doc__

        self.tag(getattr(func, "_decorated_function", func).__name__, compile_func)
        return func

Example 54

Project: django-compositepks Source File: client.py
Function: request
    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',
            'wsgi.version':      (1,0),
            'wsgi.url_scheme':   'http',
            'wsgi.errors':       self.errors,
            'wsgi.multiprocess': True,
            'wsgi.multithread':  False,
            'wsgi.run_once':     False,
        }
        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)
        signals.template_rendered.connect(on_template_render)

        # Capture exceptions created by the handler.
        got_request_exception.connect(self.store_exc_info)

        try:
            response = self.handler(environ)
        except TemplateDoesNotExist, 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], None, 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

Example 55

Project: django-nonrel Source File: base.py
Function: prepare
    def _prepare(cls):
        """
        Creates some methods once self._meta has been populated.
        """
        opts = cls._meta
        opts._prepare(cls)

        if opts.order_with_respect_to:
            cls.get_next_in_order = curry(cls._get_next_or_previous_in_order, is_next=True)
            cls.get_previous_in_order = curry(cls._get_next_or_previous_in_order, is_next=False)
            # defer creating accessors on the foreign class until we are
            # certain it has been created
            def make_foreign_order_accessors(field, model, cls):
                setattr(
                    field.rel.to,
                    'get_%s_order' % cls.__name__.lower(),
                    curry(method_get_order, cls)
                )
                setattr(
                    field.rel.to,
                    'set_%s_order' % cls.__name__.lower(),
                    curry(method_set_order, cls)
                )
            add_lazy_relation(
                cls,
                opts.order_with_respect_to,
                opts.order_with_respect_to.rel.to,
                make_foreign_order_accessors
            )

        # Give the class a docstring -- its definition.
        if cls.__doc__ is None:
            cls.__doc__ = "%s(%s)" % (cls.__name__, ", ".join([f.attname for f in opts.fields]))

        if hasattr(cls, 'get_absolute_url'):
            cls.get_absolute_url = update_wrapper(curry(get_absolute_url, opts, cls.get_absolute_url),
                                                  cls.get_absolute_url)

        signals.class_prepared.send(sender=cls)

Example 56

Project: django-dockit Source File: inlines.py
    def get_formset(self, request, view, obj=None, **kwargs):
        """Returns a BaseInlineFormSet class for use in admin add/change views."""
        if self.declared_fieldsets:
            fields = flatten_fieldsets(self.declared_fieldsets)
        else:
            fields = None
        if self.exclude is None:
            exclude = []
        else:
            exclude = list(self.exclude)
        exclude.extend(kwargs.get("exclude", []))
        exclude.extend(self.get_readonly_fields(request, obj))
        # if exclude is an empty list we use None, since that's the actual
        # default
        exclude = exclude or None
        defaults = {
            "form": self.get_form_class(request, obj), #TODO this needs meta
            "formset": self.formset,
            "fields": fields,
            "exclude": exclude,
            "formfield_callback": curry(self.formfield_for_field, request=request, view=view), #view=None
            "extra": self.extra,
            "max_num": self.max_num,
            "can_delete": self.can_delete,
            "schema": self.schema,
        }
        defaults.update(kwargs)
        return inlinedocuementformset_factory(self.model, self.dotpath, **defaults)

Example 57

Project: lettuce Source File: client.py
Function: request
    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.output(header='', sep='; '),
            'PATH_INFO':         '/',
            'QUERY_STRING':      '',
            'REMOTE_ADDR':       '127.0.0.1',
            'REQUEST_METHOD':    'GET',
            'SCRIPT_NAME':       '',
            'SERVER_NAME':       'testserver',
            'SERVER_PORT':       '80',
            'SERVER_PROTOCOL':   'HTTP/1.1',
            'wsgi.version':      (1,0),
            'wsgi.url_scheme':   'http',
            'wsgi.errors':       self.errors,
            'wsgi.multiprocess': True,
            'wsgi.multithread':  False,
            'wsgi.run_once':     False,
        }
        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)
        signals.template_rendered.connect(on_template_render, dispatch_uid="template-render")
        # Capture exceptions created by the handler.
        got_request_exception.connect(self.store_exc_info, dispatch_uid="request-exception")
        try:

            try:
                response = self.handler(environ)
            except TemplateDoesNotExist, 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], None, 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
        finally:
            signals.template_rendered.disconnect(dispatch_uid="template-render")
            got_request_exception.disconnect(dispatch_uid="request-exception")

Example 58

Project: tendenci Source File: views.py
@is_enabled('committees')
@login_required
def edit(request, id, form_class=CommitteeForm, meta_form_class=MetaForm, category_form_class=CategoryForm, template_name="committees/edit.html"):
        
    committee = get_object_or_404(Committee, pk=id)
    
    if not has_perm(request.user,'committees.change_committee',committee):
        raise Http403
        
    content_type = get_object_or_404(ContentType, app_label='committees',model='committee')
    
    #setup categories
    category = Category.objects.get_for_object(committee,'category')
    sub_category = Category.objects.get_for_object(committee,'sub_category')
        
    initial_category_form_data = {
        'app_label': 'committees',
        'model': 'committee',
        'pk': committee.pk,
        'category': getattr(category,'name','0'),
        'sub_category': getattr(sub_category,'name','0')
    }

    OfficerFormSet = inlineformset_factory(Committee, Officer, form=OfficerForm, extra=1)
    OfficerFormSet.form = staticmethod(curry(OfficerForm, committee_group=committee.group))

    if request.method == "POST":
        form = form_class(request.POST, request.FILES, instance=committee, user=request.user)
        metaform = meta_form_class(request.POST, instance=committee.meta, prefix='meta')
        categoryform = category_form_class(content_type, request.POST, initial= initial_category_form_data, prefix='category')
            
        formset = OfficerFormSet(request.POST, instance=committee, prefix="officers")
        
        if form.is_valid() and metaform.is_valid() and categoryform.is_valid() and formset.is_valid():
            committee = form.save(commit=False)
            # update all permissions and save the model
            committee = update_perms_and_save(request, form, committee)

            #save meta
            meta = metaform.save()
            committee.meta = meta
            
            officers = formset.save()
                
            ## update the category of the committee
            category_removed = False
            category = categoryform.cleaned_data['category']
            if category != '0': 
                Category.objects.update(committee ,category,'category')
            else: # remove
                category_removed = True
                Category.objects.remove(committee ,'category')
                Category.objects.remove(committee ,'sub_category')
            
            if not category_removed:
                # update the sub category of the committee
                sub_category = categoryform.cleaned_data['sub_category']
                if sub_category != '0': 
                    Category.objects.update(committee, sub_category,'sub_category')
                else: # remove
                    Category.objects.remove(committee,'sub_category')    
            
            #save relationships
            committee.save()

            EventLog.objects.log(instance=committee)

            messages.add_message(request, messages.SUCCESS, 'Successfully updated %s' % committee)

            if not request.user.profile.is_superuser:
                # send notification to administrators
                recipients = get_notice_recipients('module', 'committees', 'committeerecipients')
                if recipients:
                    if notification:
                        extra_context = {
                            'object': committee,
                            'request': request,
                        }
                        notification.send_emails(recipients, 'committee_edited', extra_context)

            return HttpResponseRedirect(reverse('committees.detail', args=[committee.slug]))
    else:
        form = form_class(instance=committee, user=request.user)
        metaform = meta_form_class(instance=committee.meta, prefix='meta')
        categoryform = category_form_class(content_type, initial=initial_category_form_data, prefix='category')
        formset = OfficerFormSet(instance=committee, prefix="officers")
        #formset.form = staticmethod(curry(OfficerForm, committee_group=committee.group))

    return render_to_response(template_name,
        {
            'committee': committee,
            'form': form,
            'metaform': metaform,
            'categoryform': categoryform,
            'formset': formset,
        },
        context_instance=RequestContext(request))

Example 59

Project: django-formapi Source File: tests.py
Function: set_up
    def setUp(self):
        self.dumps = curry(json.dumps, cls=DjangoJSONEncoder)

Example 60

Project: django-common Source File: admin.py
    def get_formset(self, request, obj=None, **kwargs):
        """
        Returns a BaseInlineFormSet class for use in admin add/change views.
        """
        if self.declared_fieldsets:
            fields = flatten_fieldsets(self.declared_fieldsets)
        else:
            fields = None
        if self.exclude is None:
            exclude = []
        else:
            exclude = list(self.exclude)

        exclude.extend(kwargs.get("exclude", []))
        exclude.extend(self.get_readonly_fields(request, obj))

        # if exclude is an empty list we use None, since that's the actual
        # default
        exclude = exclude or None
        defaults = {
            "form": self.form,
            "formset": self.formset,
            "fk_name": self.fk_name,
            "fields": fields,
            "exclude": exclude,
            "formfield_callback": curry(self.formfield_for_dbfield, request=request),
            "extra": self.extra,
            "max_num": self.max_num,
            "can_delete": self.can_delete,
        }
        defaults.update(kwargs)

        return inlineformset_factory(self.parent_model, self.model, **defaults)

Example 61

Project: django-compositepks Source File: related.py
Function: contribute_to_class
    def contribute_to_class(self, cls, name):
        # To support multiple relations to self, it's useful to have a non-None
        # related name on symmetrical relations for internal reasons. The
        # concept doesn't make a lot of sense externally ("you want me to
        # specify *what* on my non-reversible relation?!"), so we set it up
        # automatically. The funky name reduces the chance of an accidental
        # clash.
        if self.rel.symmetrical and self.rel.to == "self" and self.rel.related_name is None:
            self.rel.related_name = "%s_rel_+" % name

        super(ManyToManyField, self).contribute_to_class(cls, name)
        # Add the descriptor for the m2m relation
        setattr(cls, self.name, ReverseManyRelatedObjectsDescriptor(self))

        # Set up the accessor for the m2m table name for the relation
        self.m2m_db_table = curry(self._get_m2m_db_table, cls._meta)

        # Populate some necessary rel arguments so that cross-app relations
        # work correctly.
        if isinstance(self.rel.through, basestring):
            def resolve_through_model(field, model, cls):
                field.rel.through_model = model
            add_lazy_relation(cls, self, self.rel.through, resolve_through_model)
        elif self.rel.through:
            self.rel.through_model = self.rel.through
            self.rel.through = self.rel.through._meta.object_name

        if isinstance(self.rel.to, basestring):
            target = self.rel.to
        else:
            target = self.rel.to._meta.db_table
        cls._meta.duplicate_targets[self.column] = (target, "m2m")

Example 62

Project: django-nonrel Source File: base.py
    def inclusion_tag(self, file_name, context_class=Context, takes_context=False):
        def dec(func):
            params, xx, xxx, defaults = getargspec(func)
            if takes_context:
                if params[0] == 'context':
                    params = params[1:]
                else:
                    raise TemplateSyntaxError("Any tag function decorated with takes_context=True must have a first argument of 'context'")

            class InclusionNode(Node):
                def __init__(self, vars_to_resolve):
                    self.vars_to_resolve = map(Variable, vars_to_resolve)

                def render(self, context):
                    resolved_vars = [var.resolve(context) for var in self.vars_to_resolve]
                    if takes_context:
                        args = [context] + resolved_vars
                    else:
                        args = resolved_vars

                    dict = func(*args)

                    if not getattr(self, 'nodelist', False):
                        from django.template.loader import get_template, select_template
                        if not isinstance(file_name, basestring) and is_iterable(file_name):
                            t = select_template(file_name)
                        else:
                            t = get_template(file_name)
                        self.nodelist = t.nodelist
                    new_context = context_class(dict, autoescape=context.autoescape)
                    # Copy across the CSRF token, if present, because inclusion
                    # tags are often used for forms, and we need instructions
                    # for using CSRF protection to be as simple as possible.
                    csrf_token = context.get('csrf_token', None)
                    if csrf_token is not None:
                        new_context['csrf_token'] = csrf_token
                    return self.nodelist.render(new_context)

            compile_func = curry(generic_tag_compiler, params, defaults, getattr(func, "_decorated_function", func).__name__, InclusionNode)
            compile_func.__doc__ = func.__doc__
            self.tag(getattr(func, "_decorated_function", func).__name__, compile_func)
            return func
        return dec

Example 63

Project: django-repositories Source File: admin.py
    def get_form(self, request, obj=None, **kwargs):
        """
        Return a different set of fields if the form is shown in a popup window
        versus a normal window. To provide better integration with a project
        manager, which will presumably be managing certain information, we 
        include only the bare necessity of fields in the popup menu.
        
        This is pretty much copied from Django source, with a bit to make it work
        with 1.1 as well as 1.2.
        
        Returns a Form class for use in the admin add view. This is used by
        add_view and change_view.
        """
        from django.contrib.admin.util import flatten_fieldsets
        from django.forms.models import modelform_factory
        from django.utils.functional import curry
        
        if request.REQUEST.has_key('_popup'):
            fields = flatten_fieldsets([(None, {'fields': self.popup_fields})])
        elif self.declared_fieldsets:
            fields = flatten_fieldsets(self.declared_fieldsets)
        else:
            fields = None
        if self.exclude is None:
            exclude = []
        else:
            exclude = list(self.exclude)
        exclude.extend(kwargs.get("exclude", []))
        
        if hasattr(self, 'get_readonly_fields'):
            exclude.extend(self.get_readonly_fields(request, obj))
        # if exclude is an empty list we pass None to be consistant with the
        # default on modelform_factory
        exclude = exclude or None
        defaults = {
            "form": self.form,
            "fields": fields,
            "exclude": exclude,
            "formfield_callback": curry(self.formfield_for_dbfield, request=request),
        }
        defaults.update(kwargs)
        return modelform_factory(self.model, **defaults)

Example 64

Project: django-fluent-contents Source File: placeholdereditor.py
Function: get_formset
    def get_formset(self, request, obj=None, **kwargs):
        """
        Pre-populate formset with the initial placeholders to display.
        """
        def _placeholder_initial(p):
            # p.as_dict() returns allowed_plugins too for the client-side API.
            return {
                'slot': p.slot,
                'title': p.title,
                'role': p.role,
            }

        # Note this method is called twice, the second time in get_fieldsets() as `get_formset(request).form`
        initial = []
        if request.method == "GET":
            placeholder_admin = self._get_parent_modeladmin()

            # Grab the initial data from the parent PlaceholderEditorBaseMixin
            data = placeholder_admin.get_placeholder_data(request, obj)
            initial = [_placeholder_initial(d) for d in data]

            # Order initial properly,

        # Inject as default parameter to the constructor
        # This is the BaseExtendedGenericInlineFormSet constructor
        FormSetClass = super(PlaceholderEditorInline, self).get_formset(request, obj, **kwargs)
        FormSetClass.__init__ = curry(FormSetClass.__init__, initial=initial)
        return FormSetClass

Example 65

Project: amy Source File: apps.py
    def ready(self):
        from . import checks

        from workshops.forms import PersonForm, TaskForm, SponsorshipForm
        from workshops.models import Person, Task, Organization, Sponsorship
        from workshops.views import EventCreate, PersonCreate

        # Add choices to the `amount` field
        Sponsorship.LEVELS = (
            (0, 'Founding'),
            (15000, 'Diamond'),
            (8000, 'Platinum'),
            (5000, 'Gold'),
            (3000, 'Silver'),
            (1500, 'Supporting'),
            (1, 'Community'),
        )

        # Add choices to `amount` field
        # Django migration system complains about missing migrations
        amount_field = Sponsorship._meta.get_field('amount')
        amount_field.choices = Sponsorship.LEVELS

        # Add method `get_amount_display` to Sponsorship to return the level
        setattr(
            Sponsorship,
            'get_amount_display',
            curry(Sponsorship._get_FIELD_display, field=amount_field)
        )

        # Override the `__str__` method to display level instead of amount
        def __str__(self):
            return '{}: {}'.format(self.organization, self.get_amount_display())
        Sponsorship.add_to_class('__str__', __str__)

        # Add a regex to obtain URL of conference and `pk` of sponsor instance
        Sponsorship.PROFILE_REGEX = re.compile(r'^(?P<url>.+?(?=/sponsors))/sponsors/(?P<id>\d+)/?') # noqa

        # Add "Import from URL" button to SponsorshipForm
        class Media:
            js = ('import_sponsor.js', )
        SponsorshipForm.Media = Media

        # Add a dropdown to the `amount` field on SponsorshipForm
        SponsorshipForm.base_fields['amount'] = forms.ChoiceField(
            choices=Sponsorship.LEVELS,
        )

        # Add a regex to obtain URL of conference and `pk` of presentation
        Task.PRESENTATION_REGEX = re.compile(r'^(?P<url>.+?(?=/schedule))/schedule/presentation/(?P<id>\d+)/?') # noqa

        # Add "Import from URL" button to TaskForm
        class Media:
            js = ('import_task.js', )
        TaskForm.Media = Media

        # Add a regex to obtain URL of conference and `pk` of speaker
        Person.PROFILE_REGEX = re.compile(r'^(?P<url>.+?(?=/speaker))/speaker/profile/(?P<id>[^/]+)/?') # noqa

        # Add "Import from URL" button to PersonForm on PersonCreate view
        PersonCreate.template_name = 'pydata/person_create_form.html'

        class Media:
            js = ('import_person.js', )
        PersonForm.Media = Media

        # Prepopulate fields on EventCreate view
        def get_initial(self):
            numfocus = Organization.objects.get(fullname='NumFOCUS')
            return {
                'administrator': numfocus,
                'assigned_to': self.request.user,
            }
        EventCreate.get_initial = get_initial

Example 66

Project: feincms Source File: modeladmins.py
Function: get_form
    def get_form(self, *args, **kwargs):
        form = super(PageAdmin, self).get_form(*args, **kwargs)
        return curry(form, modeladmin=self)

Example 67

Project: django-braces Source File: _forms.py
    def __init__(self, request):
        for name in self.API:
            api_fn = getattr(messages.api, name)
            setattr(self, name, curry(api_fn, request))

Example 68

Project: django-sortedm2m Source File: fields.py
    def contribute_to_class(self, cls, name, **kwargs):
        if not self.sorted:
            return super(SortedManyToManyField, self).contribute_to_class(cls, name, **kwargs)

        # To support multiple relations to self, it's useful to have a non-None
        # related name on symmetrical relations for internal reasons. The
        # concept doesn't make a lot of sense externally ("you want me to
        # specify *what* on my non-reversible relation?!"), so we set it up
        # automatically. The funky name reduces the chance of an accidental
        # clash.
        if self.rel.symmetrical and (self.rel.to == "self" or self.rel.to == cls._meta.object_name):
            self.rel.related_name = "%s_rel_+" % name

        super(ManyToManyField, self).contribute_to_class(cls, name, **kwargs)

        # The intermediate m2m model is not auto created if:
        #  1) There is a manually specified intermediate, or
        #  2) The class owning the m2m field is abstract.
        if not self.rel.through and not cls._meta.abstract:
            self.rel.through = self.create_intermediate_model(cls)

        # Add the descriptor for the m2m relation
        setattr(cls, self.name, SortedManyToManyDescriptor(self))

        # Set up the accessor for the m2m table name for the relation
        self.m2m_db_table = curry(self._get_m2m_db_table, cls._meta)

        # Populate some necessary rel arguments so that cross-app relations
        # work correctly.
        if isinstance(self.rel.through, six.string_types):
            def resolve_through_model(field, model, cls):
                field.rel.through = model
            add_lazy_relation(cls, self, self.rel.through, resolve_through_model)

        if hasattr(cls._meta, 'duplicate_targets'):  # Django<1.5
            if isinstance(self.rel.to, six.string_types):
                target = self.rel.to
            else:
                target = self.rel.to._meta.db_table
            cls._meta.duplicate_targets[self.column] = (target, "m2m")

Example 69

Project: scielo-manager Source File: forms.py
def get_all_pressrelease_forms(post_dict, journal, pressrelease):
    """
    Get all forms/formsets used by the PressRelease form.

    :Parameters:
      - ``post_dict``: The POST querydict, even if it is empty
      - ``journal``: The journal instance the press-release is part of
      - ``pressrelease``: The instance bound to the form. Must be
        a new instance when creating an empty form
    """
    args = []
    kwargs = {}

    if pressrelease:
        kwargs['instance'] = pressrelease

    if post_dict:
        args.append(post_dict)

    translations_formset = inlineformset_factory(
        models.PressRelease,
        models.PressReleaseTranslation,
        form=PressReleaseTranslationForm,
        extra=1,
        can_delete=True,
        formset=FirstFieldRequiredFormSet)

    translations_formset.form = staticmethod(
        curry(PressReleaseTranslationForm, journal=journal))

    article_formset = inlineformset_factory(
        models.PressRelease,
        models.PressReleaseArticle,
        form=PressReleaseArticleForm,
        extra=1,
        can_delete=True)

    d = {
        'pressrelease_form': RegularPressReleaseForm(journal=journal,
                                                    *args,
                                                    **kwargs),
        'translation_formset': translations_formset(prefix='translation',
                                                    *args,
                                                    **kwargs),
        'article_formset': article_formset(prefix='article',
                                           *args,
                                           **kwargs),
    }

    return d

Example 70

Project: django-stripe Source File: backends.py
Function: get_form_class
    def get_form_class(self, request):
        return curry(StripeSubscriptionForm, initial={
            'plan': request.GET.get('plan'),
        })

Example 71

Project: django-sellmo Source File: reverse.py
    def get_formset(self, request, obj=None, **kwargs):
        if self.declared_fieldsets:
            fields = flatten_fieldsets(self.declared_fieldsets)
        else:
            fields = None
        if self.exclude is None:
            exclude = []
        else:
            exclude = list(self.exclude)
        exclude = (exclude + kwargs.get("exclude", []))
        defaults = {
            "form": self.form,
            "fields": fields,
            "exclude": exclude,
            "formfield_callback": curry(
                self.formfield_for_dbfield, request=request),
        }
        defaults.update(kwargs)
        return reverse_inlineformset_factory(
            self.parent_model, self.model, self.parent_fk_name, **defaults)

Example 72

Project: django-roa Source File: models.py
Function: prepare
    def _prepare(cls):
        """
        Creates some methods once self._meta has been populated.
        """
        opts = cls._meta
        opts._prepare(cls)

        if opts.order_with_respect_to:
            cls.get_next_in_order = curry(cls._get_next_or_previous_in_order, is_next=True)
            cls.get_previous_in_order = curry(cls._get_next_or_previous_in_order, is_next=False)

            # defer creating accessors on the foreign class until we are
            # certain it has been created
            def make_foreign_order_accessors(field, model, cls):
                setattr(
                    field.rel.to,
                    'get_%s_order' % cls.__name__.lower(),
                    curry(method_get_order, cls)
                )
                setattr(
                    field.rel.to,
                    'set_%s_order' % cls.__name__.lower(),
                    curry(method_set_order, cls)
                )
            add_lazy_relation(
                cls,
                opts.order_with_respect_to,
                opts.order_with_respect_to.rel.to,
                make_foreign_order_accessors
            )

        # Give the class a docstring -- its definition.
        if cls.__doc__ is None:
            cls.__doc__ = "%s(%s)" % (cls.__name__, ", ".join([f.attname for f in opts.fields]))

        if hasattr(cls, 'get_absolute_url'):
            cls.get_absolute_url = update_wrapper(curry(get_absolute_url, opts, cls.get_absolute_url),
                                                  cls.get_absolute_url)

        if hasattr(cls, 'get_resource_url_list'):
            cls.get_resource_url_list = staticmethod(curry(get_resource_url_list,
                                                           opts, cls.get_resource_url_list))

        if hasattr(cls, 'get_resource_url_count'):
            cls.get_resource_url_count = update_wrapper(curry(get_resource_url_count, opts, cls.get_resource_url_count),
                                                        cls.get_resource_url_count)

        if hasattr(cls, 'get_resource_url_detail'):
            cls.get_resource_url_detail = update_wrapper(curry(get_resource_url_detail, opts, cls.get_resource_url_detail),
                                                         cls.get_resource_url_detail)

        signals.class_prepared.send(sender=cls)

Example 73

Project: scielo-manager Source File: forms.py
def get_all_ahead_pressrelease_forms(post_dict, journal, pressrelease):
    """
    Get all forms/formsets used by the AheadPressRelease form.

    :Parameters:
      - ``post_dict``: The POST querydict, even if it is empty
      - ``journal``: The journal instance the press-release is part of
      - ``pressrelease``: The instance bound to the form. Must be
        a new instance when creating an empty form
    """
    args = []
    kwargs = {}

    if pressrelease:
        kwargs['instance'] = pressrelease

    if post_dict:
        args.append(post_dict)

    translations_formset = inlineformset_factory(
        models.PressRelease,
        models.PressReleaseTranslation,
        form=PressReleaseTranslationForm,
        extra=1,
        can_delete=True,
        formset=FirstFieldRequiredFormSet)

    translations_formset.form = staticmethod(
        curry(PressReleaseTranslationForm, journal=journal))

    article_formset = inlineformset_factory(
        models.PressRelease,
        models.PressReleaseArticle,
        form=AheadPressReleaseArticleForm,
        extra=1,
        can_delete=True,
        formset=FirstFieldRequiredFormSet)

    d = {
        'pressrelease_form': AheadPressReleaseForm(*args,
                                                   **kwargs),
        'translation_formset': translations_formset(prefix='translation',
                                                    *args,
                                                    **kwargs),
        'article_formset': article_formset(prefix='article',
                                           *args,
                                           **kwargs),
    }

    return d

Example 74

Project: django-nonrel Source File: base.py
Function: simple_tag
    def simple_tag(self, func=None, takes_context=None):
        def dec(func):
            params, xx, xxx, defaults = getargspec(func)
            if takes_context:
                if params[0] == 'context':
                    params = params[1:]
                else:
                    raise TemplateSyntaxError("Any tag function decorated with takes_context=True must have a first argument of 'context'")

            class SimpleNode(Node):
                def __init__(self, vars_to_resolve):
                    self.vars_to_resolve = map(Variable, vars_to_resolve)

                def render(self, context):
                    resolved_vars = [var.resolve(context) for var in self.vars_to_resolve]
                    if takes_context:
                        func_args = [context] + resolved_vars
                    else:
                        func_args = resolved_vars
                    return func(*func_args)

            compile_func = curry(generic_tag_compiler, params, defaults, getattr(func, "_decorated_function", func).__name__, SimpleNode)
            compile_func.__doc__ = func.__doc__
            self.tag(getattr(func, "_decorated_function", func).__name__, compile_func)
            return func

        if func is None:
            # @register.simple_tag(...)
            return dec
        elif callable(func):
            # @register.simple_tag
            return dec(func)
        else:
            raise TemplateSyntaxError("Invalid arguments provided to simple_tag")

Example 75

Project: fancy_tag Source File: __init__.py
def fancy_tag(library, takes_context=False):
    def inner(func):
        params, var_args_var, var_kwargs_var, defaults = getargspec(func)

        class FancyNode(Node):
            def __init__(self, vars_to_resolve, kw_vars_to_resolve, output_var, takes_context):
                self.vars_to_resolve = map(Variable, vars_to_resolve)
                self.kw_vars_to_resolve = dict(
                        [(kw, Variable(var)) for kw, var in kw_vars_to_resolve.items()])
                self.output_var = output_var
                self.takes_context = takes_context

            def safe_resolve(self, var, context):
                try:
                    return var.resolve(context)
                except VariableDoesNotExist:
                    return settings.TEMPLATE_STRING_IF_INVALID

            def render(self, context):
                args = [self.safe_resolve(var, context) for var in self.vars_to_resolve]
                kwargs = dict(
                        [(kw, self.safe_resolve(var, context)) for kw, var in self.kw_vars_to_resolve.items()])

                if self.takes_context:
                    args = [context] + args

                if self.output_var is not None:
                    context[self.output_var] = func(*args, **kwargs)
                    return ''
                else:
                    return func(*args, **kwargs)

        compile_func = curry(
                fancy_tag_compiler,
                params,
                defaults,
                var_args_var is not None,
                var_kwargs_var is not None,
                takes_context,
                getattr(func, "_decorated_function", func).__name__,
                FancyNode
                )
        compile_func.__doc__ = func.__doc__
        library.tag(getattr(func, "_decorated_function", func).__name__, compile_func)
        return func
    return inner

Example 76

Project: decode-Django Source File: base.py
Function: prepare
    def _prepare(cls):
        """
        Creates some methods once self._meta has been populated.
        """
        opts = cls._meta
        opts._prepare(cls)

        if opts.order_with_respect_to:
            cls.get_next_in_order = curry(cls._get_next_or_previous_in_order, is_next=True)
            cls.get_previous_in_order = curry(cls._get_next_or_previous_in_order, is_next=False)

            # defer creating accessors on the foreign class until we are
            # certain it has been created
            def make_foreign_order_accessors(field, model, cls):
                setattr(
                    field.rel.to,
                    'get_%s_order' % cls.__name__.lower(),
                    curry(method_get_order, cls)
                )
                setattr(
                    field.rel.to,
                    'set_%s_order' % cls.__name__.lower(),
                    curry(method_set_order, cls)
                )
            add_lazy_relation(
                cls,
                opts.order_with_respect_to,
                opts.order_with_respect_to.rel.to,
                make_foreign_order_accessors
            )

        # Give the class a docstring -- its definition. 创建一些说明文档
        if cls.__doc__ is None:
            cls.__doc__ = "%s(%s)" % (cls.__name__, ", ".join([f.attname for f in opts.fields]))

        if hasattr(cls, 'get_absolute_url'):
            cls.get_absolute_url = update_wrapper(curry(get_absolute_url, opts, cls.get_absolute_url),
                                                  cls.get_absolute_url)

        signals.class_prepared.send(sender=cls)

Example 77

Project: django-nonrel Source File: client.py
Function: request
    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 = self._base_environ(**request)

        # Curry a data dictionary into an instance of the template renderer
        # callback function.
        data = {}
        on_template_render = curry(store_rendered_templates, data)
        signals.template_rendered.connect(on_template_render, dispatch_uid="template-render")
        # Capture exceptions created by the handler.
        got_request_exception.connect(self.store_exc_info, dispatch_uid="request-exception")
        try:

            try:
                response = self.handler(environ)
            except TemplateDoesNotExist, 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], None, 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.
            response.templates = data.get("templates", [])
            response.context = data.get("context")

            # Flatten a single context. Not really necessary anymore thanks to
            # the __getattr__ flattening in ContextList, but has some edge-case
            # backwards-compatibility implications.
            if response.context and len(response.context) == 1:
                response.context = response.context[0]

            # Provide a backwards-compatible (but pending deprecation) response.template
            def _get_template(self):
                warnings.warn("response.template is deprecated; use response.templates instead (which is always a list)",
                              PendingDeprecationWarning, stacklevel=2)
                if not self.templates:
                    return None
                elif len(self.templates) == 1:
                    return self.templates[0]
                return self.templates
            response.__class__.template = property(_get_template)

            # Update persistent cookie data.
            if response.cookies:
                self.cookies.update(response.cookies)

            return response
        finally:
            signals.template_rendered.disconnect(dispatch_uid="template-render")
            got_request_exception.disconnect(dispatch_uid="request-exception")

Example 78

Project: ProjectNarwhal Source File: fields.py
Function: contribute_to_class
    def contribute_to_class(self, cls, name):
        self.set_attributes_from_name(name)
        self.model = cls
        cls._meta.add_field(self)
        setattr(cls, 'get_%s_display' % self.name, curry(self.get_for_display, field=self))

Example 79

Project: django-compositepks Source File: __init__.py
    def inclusion_tag(self, file_name, context_class=Context, takes_context=False):
        def dec(func):
            params, xx, xxx, defaults = getargspec(func)
            if takes_context:
                if params[0] == 'context':
                    params = params[1:]
                else:
                    raise TemplateSyntaxError("Any tag function decorated with takes_context=True must have a first argument of 'context'")

            class InclusionNode(Node):
                def __init__(self, vars_to_resolve):
                    self.vars_to_resolve = map(Variable, vars_to_resolve)

                def render(self, context):
                    resolved_vars = [var.resolve(context) for var in self.vars_to_resolve]
                    if takes_context:
                        args = [context] + resolved_vars
                    else:
                        args = resolved_vars

                    dict = func(*args)

                    if not getattr(self, 'nodelist', False):
                        from django.template.loader import get_template, select_template
                        if not isinstance(file_name, basestring) and is_iterable(file_name):
                            t = select_template(file_name)
                        else:
                            t = get_template(file_name)
                        self.nodelist = t.nodelist
                    return self.nodelist.render(context_class(dict,
                            autoescape=context.autoescape))

            compile_func = curry(generic_tag_compiler, params, defaults, getattr(func, "_decorated_function", func).__name__, InclusionNode)
            compile_func.__doc__ = func.__doc__
            self.tag(getattr(func, "_decorated_function", func).__name__, compile_func)
            return func
        return dec

Example 80

Project: django-evolution Source File: mutations.py
Function: add_m2m_table
    def add_m2m_table(self, mutator, model):
        field = create_field(mutator.proj_sig, self.field_name,
                             self.field_type, self.field_attrs, model)

        related_app_label, related_model_name = \
            self.field_attrs['related_model'].split('.')
        related_sig = mutator.proj_sig[related_app_label][related_model_name]
        related_model = MockModel(mutator.proj_sig, related_app_label,
                                  related_model_name, related_sig,
                                  mutator.database)
        related = MockRelated(related_model, model, field)

        if hasattr(field, '_get_m2m_column_name'):
            # Django < 1.2
            field.m2m_column_name = \
                curry(field._get_m2m_column_name, related)
            field.m2m_reverse_name = \
                curry(field._get_m2m_reverse_name, related)
        else:
            # Django >= 1.2
            field.m2m_column_name = curry(field._get_m2m_attr,
                                          related, 'column')
            field.m2m_reverse_name = curry(field._get_m2m_reverse_attr,
                                           related, 'column')

        mutator.add_sql(self, mutator.evolver.add_m2m_table(model, field))

Example 81

Project: django Source File: client.py
    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 = self._base_environ(**request)

        # Curry a data dictionary into an instance of the template renderer
        # callback function.
        data = {}
        on_template_render = curry(store_rendered_templates, data)
        signal_uid = "template-render-%s" % id(request)
        signals.template_rendered.connect(on_template_render, dispatch_uid=signal_uid)
        # Capture exceptions created by the handler.
        exception_uid = "request-exception-%s" % id(request)
        got_request_exception.connect(self.store_exc_info, dispatch_uid=exception_uid)
        try:
            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
                six.reraise(*exc_info)

            # Save the client and request that stimulated the response.
            response.client = self
            response.request = request

            # Add any rendered template detail to the response.
            response.templates = data.get("templates", [])
            response.context = data.get("context")

            response.json = curry(self._parse_json, response)

            # Attach the ResolverMatch instance to the response
            response.resolver_match = SimpleLazyObject(lambda: resolve(request['PATH_INFO']))

            # Flatten a single context. Not really necessary anymore thanks to
            # the __getattr__ flattening in ContextList, but has some edge-case
            # backwards-compatibility implications.
            if response.context and len(response.context) == 1:
                response.context = response.context[0]

            # Update persistent cookie data.
            if response.cookies:
                self.cookies.update(response.cookies)

            return response
        finally:
            signals.template_rendered.disconnect(dispatch_uid=signal_uid)
            got_request_exception.disconnect(dispatch_uid=exception_uid)

Example 82

Project: nodewatcher Source File: fields.py
Function: contribute_to_class
    def contribute_to_class(self, cls, name, virtual_only=False):
        """
        Augments the containing class.
        """

        super(RegistryChoiceFieldMixin, self).contribute_to_class(cls, name, virtual_only)

        def get_FIELD_choice(self, field):
            value = getattr(self, field.attname)
            choices = registration.point(field.regpoint).get_registered_choices(field.enum_id)

            try:
                return choices.resolve(value)
            except KeyError:
                try:
                    return choices.resolve(field.default)
                except KeyError:
                    return None

        setattr(
            cls,
            'get_%s_choice' % self.name,
            functional.curry(get_FIELD_choice, field=self)
        )

Example 83

Project: django-webtest Source File: __init__.py
    def do_request(self, req, status, expect_errors):

        # Django closes the database connection after every request;
        # this breaks the use of transactions in your tests.
        if close_old_connections is not None:  # Django 1.6+
            signals.request_started.disconnect(close_old_connections)
            signals.request_finished.disconnect(close_old_connections)
        else:  # Django < 1.6
            signals.request_finished.disconnect(close_connection)

        try:
            req.environ.setdefault('REMOTE_ADDR', '127.0.0.1')

            # is this a workaround for
            # https://code.djangoproject.com/ticket/11111 ?
            req.environ['REMOTE_ADDR'] = to_string(req.environ['REMOTE_ADDR'])
            req.environ['PATH_INFO'] = to_string(req.environ['PATH_INFO'])

            # Curry a data dictionary into an instance of the template renderer
            # callback function.
            data = {}
            on_template_render = curry(store_rendered_templates, data)
            template_rendered.connect(on_template_render)

            response = super(DjangoTestApp, self).do_request(req, status,
                                                             expect_errors)

            # 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.
            def flattend(detail):
                if len(data[detail]) == 1:
                    return data[detail][0]
                return data[detail]

            response.context = None
            response.template = None
            response.templates = data.get('templates', None)

            if data.get('context'):
                response.context = flattend('context')

            if data.get('template'):
                response.template = flattend('template')
            elif data.get('templates'):
                response.template = flattend('templates')

            response.__class__ = self.response_class
            return response
        finally:
            if close_old_connections:  # Django 1.6+
                signals.request_started.connect(close_old_connections)
                signals.request_finished.connect(close_old_connections)
            else:  # Django < 1.6
                signals.request_finished.connect(close_connection)

Example 84

Project: django-adminactions Source File: mass_update.py
    def _clean_fields(self):
        for name, field in list(self.fields.items()):
            raw_value = field.widget.value_from_datadict(self.data, self.files, self.add_prefix(name))
            try:
                if isinstance(field, ff.FileField):
                    initial = self.initial.get(name, field.initial)
                    value = field.clean(raw_value, initial)
                else:
                    enabler = 'chk_id_%s' % name
                    function = self.data.get('func_id_%s' % name, False)
                    if self.data.get(enabler, False):
                        # field_object, model, direct, m2m = self._meta.model._meta.get_field_by_name(name)
                        field_object, model, direct, m2m = get_field_by_name(self._meta.model, name)
                        value = field.clean(raw_value)
                        if function:
                            func, hasparm, __, __ = OPERATIONS.get_for_field(field_object)[function]
                            if func is None:
                                pass
                            elif hasparm:
                                value = curry(func, value)
                            else:
                                value = func

                        self.cleaned_data[name] = value
                    if hasattr(self, 'clean_%s' % name):
                        value = getattr(self, 'clean_%s' % name)()
                        self.cleaned_data[name] = value
            except ValidationError as e:
                self._errors[name] = self.error_class(e.messages)
                if name in self.cleaned_data:
                    del self.cleaned_data[name]

Example 85

Project: django-machina Source File: fields.py
def _get_render_function(dotted_path, kwargs):
    module, func = dotted_path.rsplit('.', 1)
    module, func = smart_str(module), smart_str(func)
    func = getattr(__import__(module, {}, {}, [func]), func)
    return curry(func, **kwargs)

Example 86

Project: django-markitup Source File: fields.py
def _get_render_func(dotted_path, **kwargs):
    # Don't coerce to unicode on python 2
    (module, func) = dotted_path.rsplit(str('.'), 1)
    func = getattr(__import__(module, {}, {}, [func]), func)
    return curry(func, **kwargs)

Example 87

Project: lettuce Source File: models.py
    @step(txt)
    def write_models_generic(step, model, field=None):
        """
        And I have foos in the database:
            | name | bar  |
            | Baz  | Quux |

        And I update existing foos by pk in the database:
            | pk | name |
            | 1  | Bar  |

        The generic method can be overridden for a specific model by defining a
        function write_badgers(step, field), which creates and updates
        the Badger model and decorating it with the writes_models(model_class)
        decorator.

            @writes_models(Profile)
            def write_profile(step, field):
                '''Creates a Profile model'''

                for hash_ in hashes_data(step):
                    if field:
                        profile = Profile.objects.get(**{field: hash_[field]})
                    else:
                        profile = Profile()

                    ...
        """

        model = get_model(model)

        try:
            func = _WRITE_MODEL[model]
        except KeyError:
            func = curry(write_models, model)
        func(step, field)

Example 88

Project: django-mailserver Source File: test.py
    def request(self, request):
        environ = { }
        environ.update(self.defaults)

        # curry a data dictionary into an instance of the template renderer
        # callback function.
        data = {}
        on_template_render = curry(client.store_rendered_templates, data)
        signals.template_rendered.connect(on_template_render)

        ## capture exceptions created by the handler.
        #got_request_exception.connect(self.store_exc_info)

        response = self.handler(environ, request)

        if self.exc_info:
            exc_info = self.exc_info
            self.exc_info = none
            raise exc_info[1], none, 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)

        return response

Example 89

Project: django-test-extensions Source File: codecoverage.py
def run_tests(test_labels, verbosity=1, interactive=True,
        extra_tests=[], nodatabase=False, xml_out=False, callgraph=False, html_only=False):
    """
    Test runner which displays a code coverage report at the end of the
    run.
    """
    cov = coverage.coverage()
    cov.erase()
    cov.use_cache(0)

    test_labels = test_labels or getattr(settings, "TEST_APPS", None)
    cover_branch = getattr(settings, "COVERAGE_BRANCH_COVERAGE", False)
    cov = coverage.coverage(branch=cover_branch, cover_pylib=False)
    cov.use_cache(0)
     
    coverage_modules = []
    if test_labels:
        for label in test_labels:
            # Don't report coverage if you're only running a single
            # test case.
            if '.' not in label:
                app = get_app(label)
                coverage_modules.extend(get_all_coverage_modules(app))
    else:
        for app in get_apps():
            coverage_modules.extend(get_all_coverage_modules(app))

    morfs = filter(is_wanted_module, coverage_modules)

    if callgraph:
        try:
            import pycallgraph
            #_include = [i.__name__ for i in coverage_modules]
            _included = getattr(settings, "COVERAGE_INCLUDE_MODULES", [])
            _excluded = getattr(settings, "COVERAGE_EXCLUDE_MODULES", [])

            _included = [i.strip('*')+'*' for i in _included]
            _excluded = [i.strip('*')+'*' for i in _included]

            _filter_func = pycallgraph.GlobbingFilter(
                include=_included or ['*'],
                #include=['lotericas.*'],
                #exclude=[],
                #max_depth=options.max_depth,
            )

            pycallgraph_enabled = True
        except ImportError:
            pycallgraph_enabled = False
    else:
        pycallgraph_enabled = False

    cov.start()
    
    if pycallgraph_enabled:
        pycallgraph.start_trace(filter_func=_filter_func)

    if nodatabase:
        results = nodatabase_run_tests(test_labels, verbosity, interactive,
            extra_tests)
    else:
        results = django_test_runner(test_labels, verbosity, interactive,
            extra_tests)
    
    if callgraph and pycallgraph_enabled:
        pycallgraph.stop_trace()

    cov.stop()
    
    if getattr(settings, "COVERAGE_HTML_REPORT", False) or \
            os.environ.get("COVERAGE_HTML_REPORT"):
        output_dir = getattr(settings, "COVERAGE_HTML_DIRECTORY", "covhtml")
        report_method = curry(cov.html_report, directory=output_dir)
        if callgraph and pycallgraph_enabled:
            callgraph_path = output_dir + '/' + 'callgraph.png'
            pycallgraph.make_dot_graph(callgraph_path)

        print >>sys.stdout
        print >>sys.stdout, "Coverage HTML reports were output to '%s'" %output_dir
        if callgraph:
            if pycallgraph_enabled:
                print >>sys.stdout, "Call graph was output to '%s'" %callgraph_path
            else:
                print >>sys.stdout, "Call graph was not generated: Install 'pycallgraph' module to do so"

    else:
        report_method = cov.report

    if coverage_modules:
        if xml_out:
            # using the same output directory as the --xml function uses for testing
            if not os.path.isdir(os.path.join("temp", "xml")):
                os.makedirs(os.path.join("temp", "xml"))
            output_filename = 'temp/xml/coverage_output.xml'
            cov.xml_report(morfs=coverage_modules, outfile=output_filename)

        if not html_only:
            cov.report(coverage_modules, show_missing=1)

    return results

Example 90

Project: django-sqlalchemy Source File: query_utils.py
def _lookup_query_expression(lookup_type, field, value):
    if lookup_type in QUERY_TERMS_MAPPING:
        return curry(QUERY_TERMS_MAPPING[lookup_type], field, value)
    elif lookup_type == 'contains':
        return curry(field.like, '%%%s%%' % value)
    elif lookup_type == 'icontains':
        return curry(field.ilike, '%%%s%%' % value)
    elif lookup_type == 'in':
        return curry(field.in_, value)
    elif lookup_type == 'startswith':        
        return curry(field.like, '%s%%' % value)
    elif lookup_type == 'like':        
        return curry(field.like, '%s' % value)
    elif lookup_type == 'ilike':        
        return curry(field.ilike, '%s' % value)    
    elif lookup_type == 'istartswith':
        return curry(field.ilike, '%s%%' % value)
    elif lookup_type == 'endswith':
        return curry(field.like, '%%%s' % value)
    elif lookup_type == 'iendswith':
        return curry(field.ilike, '%%%s' % value)
    elif lookup_type == 'range':
        return curry(field.between, *value)
    elif lookup_type == 'year':        
        return curry(field.between, *_get_range_lookup(lookup_type, field, value))
    elif lookup_type == 'month':
        raise NotImplementedError()
    elif lookup_type == 'day':
        raise NotImplementedError()
    elif lookup_type == 'search':
        raise NotImplementedError()
    elif lookup_type == 'regex':
        raise NotImplementedError()
    elif lookup_type == 'iregex':
        raise NotImplementedError()
    elif lookup_type == 'isnull': 
        if value:
            return curry(operator.eq, field, None)
        else:
            return curry(operator.ne, field, None)
    else:
        return None

Example 91

Project: hortonworks-sandbox Source File: editor.py
@check_job_access_permission
@check_job_edition_permission(True)
def edit_coordinator(request, coordinator):
  history = History.objects.filter(submitter=request.user, job=coordinator).order_by('-submission_date')

  DatasetFormSet = inlineformset_factory(Coordinator, Dataset, form=DatasetForm, max_num=0, can_order=False, can_delete=True)
  DataInputFormSet = inlineformset_factory(Coordinator, DataInput, form=DataInputSetForm, max_num=0, can_order=False, can_delete=True)
  DataOutputFormSet = inlineformset_factory(Coordinator, DataOutput, form=DataOutputSetForm, max_num=0, can_order=False, can_delete=True)

  dataset = Dataset(coordinator=coordinator)
  dataset_form = DatasetForm(instance=dataset, prefix='create')

  NewDataInputFormSet = inlineformset_factory(Coordinator, DataInput, form=DataInputForm, extra=0, can_order=False, can_delete=False)
  NewDataInputFormSet.form = staticmethod(curry(DataInputForm, coordinator=coordinator))
  NewDataOutputFormSet = inlineformset_factory(Coordinator, DataOutput, form=DataOutputForm, extra=0, can_order=False, can_delete=False)
  NewDataOutputFormSet.form = staticmethod(curry(DataOutputForm, coordinator=coordinator))

  if request.method == 'POST':
    coordinator_form = CoordinatorForm(request.POST, instance=coordinator, user=request.user)
    dataset_formset = DatasetFormSet(request.POST, request.FILES, instance=coordinator)
    data_input_formset = DataInputFormSet(request.POST, request.FILES, instance=coordinator)
    data_output_formset = DataOutputFormSet(request.POST, request.FILES, instance=coordinator)
    new_data_input_formset = NewDataInputFormSet(request.POST, request.FILES, instance=coordinator, prefix='input')
    new_data_output_formset = NewDataOutputFormSet(request.POST, request.FILES, instance=coordinator, prefix='output')

    if coordinator_form.is_valid() and dataset_formset.is_valid() and data_input_formset.is_valid() and data_output_formset.is_valid() \
        and new_data_input_formset.is_valid() and new_data_output_formset.is_valid():
      coordinator = coordinator_form.save()
      dataset_formset.save()
      data_input_formset.save()
      data_output_formset.save()
      new_data_input_formset.save()
      new_data_output_formset.save()

      request.info(_('Coordinator saved!'))
      return redirect(reverse('oozie:edit_coordinator', kwargs={'coordinator': coordinator.id}))
  else:
    coordinator_form = CoordinatorForm(instance=coordinator, user=request.user)
    dataset_formset = DatasetFormSet(instance=coordinator)
    data_input_formset = DataInputFormSet(instance=coordinator)
    data_output_formset = DataOutputFormSet(instance=coordinator)
    new_data_input_formset = NewDataInputFormSet(queryset=DataInput.objects.none(), instance=coordinator, prefix='input')
    new_data_output_formset = NewDataOutputFormSet(queryset=DataOutput.objects.none(), instance=coordinator, prefix='output')

  return render('editor/edit_coordinator.mako', request, {
    'coordinator': coordinator,
    'coordinator_form': coordinator_form,
    'dataset_formset': dataset_formset,
    'data_input_formset': data_input_formset,
    'data_output_formset': data_output_formset,
    'dataset_form': dataset_form,
    'new_data_input_formset': new_data_input_formset,
    'new_data_output_formset': new_data_output_formset,
    'history': history,
    'parameters': extract_field_data(coordinator_form['parameters'])
  })

Example 92

Project: django-test-plus Source File: test.py
Function: get_response
    def get_response(self, request, view_func):
        """
        Obtain response from view class method (typically get or post).

        No middleware is invoked, but templates are rendered
        and context saved if appropriate.
        """
        # Curry a data dictionary into an instance of
        # the template renderer callback function.
        data = {}
        on_template_render = curry(store_rendered_templates, data)
        signal_uid = "template-render-%s" % id(request)
        signals.template_rendered.connect(on_template_render, dispatch_uid=signal_uid)
        try:
            response = view_func(request)

            if hasattr(response, 'render') and callable(response.render):
                response = response.render()
                # Add any rendered template detail to the response.
                response.templates = data.get("templates", [])
                response.context = data.get("context")
            else:
                response.templates = None
                response.context = None

            return response
        finally:
            signals.template_rendered.disconnect(dispatch_uid=signal_uid)

Example 93

Project: huDjango Source File: scalingimagefield.py
Function: contribute_to_class
    def contribute_to_class(self, cls, name):
        """Adds field-related functions to the model."""
        super(ScalingImageField, self).contribute_to_class(cls, name)
        setattr(cls, '%s_scaled' % self.name, curry(Imagescaler, self))

Example 94

Project: cgstudiomap Source File: client.py
    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 = self._base_environ(**request)

        # Curry a data dictionary into an instance of the template renderer
        # callback function.
        data = {}
        on_template_render = curry(store_rendered_templates, data)
        signal_uid = "template-render-%s" % id(request)
        signals.template_rendered.connect(on_template_render, dispatch_uid=signal_uid)
        # Capture exceptions created by the handler.
        exception_uid = "request-exception-%s" % id(request)
        got_request_exception.connect(self.store_exc_info, dispatch_uid=exception_uid)
        try:
            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
                six.reraise(*exc_info)

            # Save the client and request that stimulated the response.
            response.client = self
            response.request = request

            # Add any rendered template detail to the response.
            response.templates = data.get("templates", [])
            response.context = data.get("context")

            response.json = curry(self._parse_json, response)

            # Attach the ResolverMatch instance to the response
            response.resolver_match = SimpleLazyObject(
                lambda: urlresolvers.resolve(request['PATH_INFO']))

            # Flatten a single context. Not really necessary anymore thanks to
            # the __getattr__ flattening in ContextList, but has some edge-case
            # backwards-compatibility implications.
            if response.context and len(response.context) == 1:
                response.context = response.context[0]

            # Update persistent cookie data.
            if response.cookies:
                self.cookies.update(response.cookies)

            return response
        finally:
            signals.template_rendered.disconnect(dispatch_uid=signal_uid)
            got_request_exception.disconnect(dispatch_uid=exception_uid)

Example 95

Project: tendenci Source File: views.py
@login_required
def edit(request, id, form_class=StudyGroupForm, meta_form_class=MetaForm, category_form_class=CategoryForm, template_name="studygroups/edit.html"):
        
    study_group = get_object_or_404(StudyGroup, pk=id)
    
    if not has_perm(request.user,'studygroups.change_studygroup',study_group):
        raise Http403
        
    content_type = get_object_or_404(ContentType, app_label='studygroups',model='studygroup')
    
    #setup categories
    category = Category.objects.get_for_object(study_group,'category')
    sub_category = Category.objects.get_for_object(study_group,'sub_category')
        
    initial_category_form_data = {
        'app_label': 'studygroups',
        'model': 'studygroup',
        'pk': study_group.pk,
        'category': getattr(category,'name','0'),
        'sub_category': getattr(sub_category,'name','0')
    }

    OfficerFormSet = inlineformset_factory(StudyGroup, Officer, form=OfficerForm, extra=1)
    OfficerFormSet.form = staticmethod(curry(OfficerForm, study_group_group=study_group.group))

    if request.method == "POST":
        form = form_class(request.POST, request.FILES, instance=study_group, user=request.user)
        metaform = meta_form_class(request.POST, instance=study_group.meta, prefix='meta')
        categoryform = category_form_class(content_type, request.POST, initial= initial_category_form_data, prefix='category')
            
        formset = OfficerFormSet(request.POST, instance=study_group, prefix="officers")
        
        if form.is_valid() and metaform.is_valid() and categoryform.is_valid() and formset.is_valid():
            study_group = form.save(commit=False)
            # update all permissions and save the model
            study_group = update_perms_and_save(request, form, study_group)

            #save meta
            meta = metaform.save()
            study_group.meta = meta
            
            officers = formset.save()
                
            ## update the category of the studygroup
            category_removed = False
            category = categoryform.cleaned_data['category']
            if category != '0': 
                Category.objects.update(study_group ,category,'category')
            else: # remove
                category_removed = True
                Category.objects.remove(study_group ,'category')
                Category.objects.remove(study_group ,'sub_category')
            
            if not category_removed:
                # update the sub category of the studygroup
                sub_category = categoryform.cleaned_data['sub_category']
                if sub_category != '0': 
                    Category.objects.update(study_group, sub_category,'sub_category')
                else: # remove
                    Category.objects.remove(study_group,'sub_category')    
            
            #save relationships
            study_group.save()

            EventLog.objects.log(instance=study_group)

            messages.add_message(request, messages.SUCCESS, 'Successfully updated %s' % study_group)

            if not request.user.profile.is_superuser:
                # send notification to administrators
                recipients = get_notice_recipients('module', 'studygroups', 'studygrouprecipients')
                if recipients:
                    if notification:
                        extra_context = {
                            'object': study_group,
                            'request': request,
                        }
                        notification.send_emails(recipients, 'study_group_edited', extra_context)

            return HttpResponseRedirect(reverse('studygroups.detail', args=[study_group.slug]))
    else:
        form = form_class(instance=study_group, user=request.user)
        metaform = meta_form_class(instance=study_group.meta, prefix='meta')
        categoryform = category_form_class(content_type, initial=initial_category_form_data, prefix='category')
        formset = OfficerFormSet(instance=study_group, prefix="officers")
        #formset.form = staticmethod(curry(OfficerForm, study_group_group=study_group.group))

    return render_to_response(template_name,
        {
            'study_group': study_group,
            'form': form,
            'metaform': metaform,
            'categoryform': categoryform,
            'formset': formset,
        },
        context_instance=RequestContext(request))

Example 96

Project: PyClassLessons Source File: client.py
    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 = self._base_environ(**request)

        # Curry a data dictionary into an instance of the template renderer
        # callback function.
        data = {}
        on_template_render = curry(store_rendered_templates, data)
        signal_uid = "template-render-%s" % id(request)
        signals.template_rendered.connect(on_template_render, dispatch_uid=signal_uid)
        # Capture exceptions created by the handler.
        got_request_exception.connect(self.store_exc_info, dispatch_uid="request-exception")
        try:

            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
                six.reraise(*exc_info)

            # Save the client and request that stimulated the response.
            response.client = self
            response.request = request

            # Add any rendered template detail to the response.
            response.templates = data.get("templates", [])
            response.context = data.get("context")

            # Flatten a single context. Not really necessary anymore thanks to
            # the __getattr__ flattening in ContextList, but has some edge-case
            # backwards-compatibility implications.
            if response.context and len(response.context) == 1:
                response.context = response.context[0]

            # Update persistent cookie data.
            if response.cookies:
                self.cookies.update(response.cookies)

            return response
        finally:
            signals.template_rendered.disconnect(dispatch_uid=signal_uid)
            got_request_exception.disconnect(dispatch_uid="request-exception")

Example 97

Project: Django--an-app-at-a-time Source File: client.py
    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 = self._base_environ(**request)

        # Curry a data dictionary into an instance of the template renderer
        # callback function.
        data = {}
        on_template_render = curry(store_rendered_templates, data)
        signal_uid = "template-render-%s" % id(request)
        signals.template_rendered.connect(on_template_render, dispatch_uid=signal_uid)
        # Capture exceptions created by the handler.
        got_request_exception.connect(self.store_exc_info, dispatch_uid="request-exception")
        try:

            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
                six.reraise(*exc_info)

            # Save the client and request that stimulated the response.
            response.client = self
            response.request = request

            # Add any rendered template detail to the response.
            response.templates = data.get("templates", [])
            response.context = data.get("context")

            # Attach the ResolverMatch instance to the response
            response.resolver_match = SimpleLazyObject(
                lambda: urlresolvers.resolve(request['PATH_INFO']))

            # Flatten a single context. Not really necessary anymore thanks to
            # the __getattr__ flattening in ContextList, but has some edge-case
            # backwards-compatibility implications.
            if response.context and len(response.context) == 1:
                response.context = response.context[0]

            # Update persistent cookie data.
            if response.cookies:
                self.cookies.update(response.cookies)

            return response
        finally:
            signals.template_rendered.disconnect(dispatch_uid=signal_uid)
            got_request_exception.disconnect(dispatch_uid="request-exception")

Example 98

Project: django-evolution Source File: mutations.py
Function: create_field
def create_field(proj_sig, field_name, field_type, field_attrs, parent_model):
    """
    Create an instance of a field from a field signature. This is useful for
    accessing all the database property mechanisms built into fields.
    """
    # related_model isn't a valid field attribute, so it must be removed
    # prior to instantiating the field, but it must be restored
    # to keep the signature consistent.
    related_model = field_attrs.pop('related_model', None)

    if related_model:
        related_app_name, related_model_name = related_model.split('.')
        related_model_sig = proj_sig[related_app_name][related_model_name]
        to = MockModel(proj_sig, related_app_name, related_model_name,
                       related_model_sig, stub=True)

        field = field_type(to, name=field_name, **field_attrs)
        field_attrs['related_model'] = related_model
    else:
        field = field_type(name=field_name, **field_attrs)

    if field_type is ManyToManyField and parent_model is not None:
        # Starting in Django 1.2, a ManyToManyField must have a through
        # model defined. This will be set internally to an auto-created
        # model if one isn't specified. We have to fake that model.
        through_model = field_attrs.get('through_model', None)
        through_model_sig = None

        if through_model:
            through_app_name, through_model_name = through_model.split('.')
            through_model_sig = proj_sig[through_app_name][through_model_name]
        elif hasattr(field, '_get_m2m_attr'):
            # Django >= 1.2
            to = field.rel.to._meta.object_name.lower()

            if (field.rel.to == RECURSIVE_RELATIONSHIP_CONSTANT or
                to == parent_model._meta.object_name.lower()):
                from_ = 'from_%s' % to
                to = 'to_%s' % to
            else:
                from_ = parent_model._meta.object_name.lower()

            # This corresponds to the signature in
            # related.create_many_to_many_intermediary_model
            through_app_name = parent_model.app_name
            through_model_name = '%s_%s' % (parent_model._meta.object_name,
                                            field.name)
            through_model = '%s.%s' % (through_app_name, through_model_name)

            fields = OrderedDict()
            fields['id'] = {
                'field_type': AutoField,
                'primary_key': True,
            }

            fields[from_] = {
                'field_type': ForeignKey,
                'related_model': '%s.%s' % (parent_model.app_name,
                                            parent_model._meta.object_name),
                'related_name': '%s+' % through_model_name,
            }

            fields[to] = {
                'field_type': ForeignKey,
                'related_model': related_model,
                'related_name': '%s+' % through_model_name,
            }

            through_model_sig = {
                'meta': {
                    'db_table': field._get_m2m_db_table(parent_model._meta),
                    'managed': True,
                    'auto_created': True,
                    'app_label': through_app_name,
                    'unique_together': ((from_, to),),
                    'pk_column': 'id',
                },
                'fields': fields,
            }

            field.auto_created = True

        if through_model_sig:
            through = MockModel(proj_sig, through_app_name, through_model_name,
                                through_model_sig)
            field.rel.through = through

        field.m2m_db_table = curry(field._get_m2m_db_table, parent_model._meta)
        field.set_attributes_from_rel()

    field.set_attributes_from_name(field_name)

    # Needed in Django >= 1.7, for index building.
    field.model = parent_model

    return field

Example 99

Project: treeio Source File: user.py
    def process_request(self, request):
        "Process request"

        # check mobile:
        if getattr(request, 'mobile', False) and \
                not request.POST and \
                        '/m' not in request.path[:2] and \
                        '/static' not in request.path[:7]:

            if request.GET.get('nomobile', False):
                request.session['nomobile'] = True
            elif 'nomobile' not in request.session:
                return HttpResponseRedirect('/m' + request.path)

        if hasattr(request, 'user') and request.user.is_authenticated():

            domain = getattr(settings, 'CURRENT_DOMAIN', 'default')
            cache.set('treeio_%s_last' % (domain), time.time())
            if getattr(settings, 'HARDTREE_SUBSCRIPTION_BLOCKED', False) and '/accounts' not in request.path:
                return HttpResponseRedirect('/accounts/logout')

            user = None
            try:
                user = request.user.profile
                self.objects[unicode(user.id)] = {}
            except Exception:
                pass

            if not user:
                logout(request)
                return HttpResponseRedirect('/')

            do_fresh_subscribers = curry(
                self.do_fresh_subscribers, user, request)
            send_notifications_on_save = curry(
                self.send_notifications_on_save, user, request)
            send_notifications_on_delete = curry(
                self.send_notifications_on_delete, user, request)
            send_notifications_on_m2m = curry(
                self.send_notifcations_on_m2m, user, request)

            signals.pre_save.connect(
                send_notifications_on_save, dispatch_uid=request, weak=False)
            signals.post_save.connect(
                do_fresh_subscribers, dispatch_uid=request, weak=False)
            signals.pre_delete.connect(
                send_notifications_on_delete, dispatch_uid=request, weak=False)
            signals.m2m_changed.connect(
                send_notifications_on_m2m, dispatch_uid=request, weak=False)

Example 100

Project: hue Source File: editor.py
@check_job_access_permission()
@check_job_edition_permission(True)
def edit_coordinator(request, coordinator):
  history = History.objects.filter(submitter=request.user, job=coordinator).order_by('-submission_date')

  DatasetFormSet = inlineformset_factory(Coordinator, Dataset, form=DatasetForm, max_num=0, can_order=False, can_delete=True)
  DataInputFormSet = inlineformset_factory(Coordinator, DataInput, form=DataInputForm, max_num=0, can_order=False, can_delete=True)
  DataInputFormSet.form = staticmethod(curry(DataInputForm, coordinator=coordinator))
  DataOutputFormSet = inlineformset_factory(Coordinator, DataOutput, form=DataOutputForm, max_num=0, can_order=False, can_delete=True)
  DataOutputFormSet.form = staticmethod(curry(DataOutputForm, coordinator=coordinator))

  dataset = Dataset(coordinator=coordinator)
  dataset_form = DatasetForm(instance=dataset, prefix='create')

  NewDataInputFormSet = inlineformset_factory(Coordinator, DataInput, form=DataInputForm, extra=0, can_order=False, can_delete=False)
  NewDataInputFormSet.form = staticmethod(curry(DataInputForm, coordinator=coordinator))
  NewDataOutputFormSet = inlineformset_factory(Coordinator, DataOutput, form=DataOutputForm, extra=0, can_order=False, can_delete=False)
  NewDataOutputFormSet.form = staticmethod(curry(DataOutputForm, coordinator=coordinator))

  enable_cron_scheduling = ENABLE_CRON_SCHEDULING.get()

  if request.method == 'POST':
    coordinator_form = CoordinatorForm(request.POST, instance=coordinator, user=request.user)
    dataset_formset = DatasetFormSet(request.POST, request.FILES, instance=coordinator)
    data_input_formset = DataInputFormSet(request.POST, request.FILES, instance=coordinator)
    data_output_formset = DataOutputFormSet(request.POST, request.FILES, instance=coordinator)
    new_data_input_formset = NewDataInputFormSet(request.POST, request.FILES, instance=coordinator, prefix='input')
    new_data_output_formset = NewDataOutputFormSet(request.POST, request.FILES, instance=coordinator, prefix='output')

    if coordinator_form.is_valid() and dataset_formset.is_valid() and data_input_formset.is_valid() and data_output_formset.is_valid() \
        and new_data_input_formset.is_valid() and new_data_output_formset.is_valid():
      coordinator = coordinator_form.save()
      dataset_formset.save()
      data_input_formset.save()
      data_output_formset.save()
      new_data_input_formset.save()
      new_data_output_formset.save()
      coordinator.sla = json.loads(request.POST.get('sla'))
      if enable_cron_scheduling:
        coordinator.cron_frequency = {'frequency': request.POST.get('cron_frequency'), 'isAdvancedCron': request.POST.get('isAdvancedCron') == 'on'}
      coordinator.save()

      request.info(_('Coordinator saved.'))
      return redirect(reverse('oozie:edit_coordinator', kwargs={'coordinator': coordinator.id}))
  else:
    coordinator_form = CoordinatorForm(instance=coordinator, user=request.user)
    dataset_formset = DatasetFormSet(instance=coordinator)
    data_input_formset = DataInputFormSet(instance=coordinator)
    data_output_formset = DataOutputFormSet(instance=coordinator)
    new_data_input_formset = NewDataInputFormSet(queryset=DataInput.objects.none(), instance=coordinator, prefix='input')
    new_data_output_formset = NewDataOutputFormSet(queryset=DataOutput.objects.none(), instance=coordinator, prefix='output')

  return render('editor/edit_coordinator.mako', request, {
    'coordinator': coordinator,
    'coordinator_form': coordinator_form,
    'dataset_formset': dataset_formset,
    'data_input_formset': data_input_formset,
    'data_output_formset': data_output_formset,
    'dataset': dataset,
    'dataset_form': dataset_form,
    'new_data_input_formset': new_data_input_formset,
    'new_data_output_formset': new_data_output_formset,
    'history': history,
    'coordinator_frequency': json.dumps(coordinator.cron_frequency),
    'enable_cron_scheduling': enable_cron_scheduling,
  })
See More Examples - Go to Next Page
Page 1 Page 2 Selected Page 3