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
0
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
0
Example 52
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))
0
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
0
Example 54
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
0
Example 55
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)
0
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)
0
Example 57
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")
0
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))
0
Example 59
def setUp(self):
self.dumps = curry(json.dumps, cls=DjangoJSONEncoder)
0
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)
0
Example 61
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")
0
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
0
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)
0
Example 64
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
0
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
0
Example 66
def get_form(self, *args, **kwargs):
form = super(PageAdmin, self).get_form(*args, **kwargs)
return curry(form, modeladmin=self)
0
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))
0
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")
0
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
0
Example 70
def get_form_class(self, request):
return curry(StripeSubscriptionForm, initial={
'plan': request.GET.get('plan'),
})
0
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)
0
Example 72
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)
0
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
0
Example 74
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")
0
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
0
Example 76
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)
0
Example 77
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")
0
Example 78
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))
0
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
0
Example 80
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))
0
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)
0
Example 82
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)
)
0
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)
0
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]
0
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)
0
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)
0
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)
0
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
0
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
0
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
0
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'])
})
0
Example 92
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)
0
Example 93
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))
0
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)
0
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))
0
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")
0
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")
0
Example 98
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
0
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)
0
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,
})