desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'Get a week format string in strptime syntax to be used to parse the
week from url variables.'
| def get_week_format(self):
| return self.week_format
|
'Return the week for which this view should display data'
| def get_week(self):
| week = self.week
if (week is None):
try:
week = self.kwargs[u'week']
except KeyError:
try:
week = self.request.GET[u'week']
except KeyError:
raise Http404(_(u'No week specified'))
return week
|
'Get the next valid week.'
| def get_next_week(self, date):
| return _get_next_prev(self, date, is_previous=False, period=u'week')
|
'Get the previous valid week.'
| def get_previous_week(self, date):
| return _get_next_prev(self, date, is_previous=True, period=u'week')
|
'Return the start date of the next interval.
The interval is defined by start date <= item date < next start date.'
| def _get_next_week(self, date):
| return (date + datetime.timedelta(days=(7 - self._get_weekday(date))))
|
'Return the start date of the current interval.'
| def _get_current_week(self, date):
| return (date - datetime.timedelta(self._get_weekday(date)))
|
'Return the weekday for a given date.
The first day according to the week format is 0 and the last day is 6.'
| def _get_weekday(self, date):
| week_format = self.get_week_format()
if (week_format == u'%W'):
return date.weekday()
elif (week_format == u'%U'):
return ((date.weekday() + 1) % 7)
else:
raise ValueError((u'unknown week format: %s' % week_format))
|
'Get the name of the date field to be used to filter by.'
| def get_date_field(self):
| if (self.date_field is None):
raise ImproperlyConfigured((u'%s.date_field is required.' % self.__class__.__name__))
return self.date_field
|
'Returns `True` if the view should be allowed to display objects from
the future.'
| def get_allow_future(self):
| return self.allow_future
|
'Return `True` if the date field is a `DateTimeField` and `False`
if it\'s a `DateField`.'
| @cached_property
def uses_datetime_field(self):
| model = (self.get_queryset().model if (self.model is None) else self.model)
field = model._meta.get_field(self.get_date_field())
return isinstance(field, models.DateTimeField)
|
'Convert a date into a datetime when the date field is a DateTimeField.
When time zone support is enabled, `date` is assumed to be in the
current time zone, so that displayed items are consistent with the URL.'
| def _make_date_lookup_arg(self, value):
| if self.uses_datetime_field:
value = datetime.datetime.combine(value, datetime.time.min)
if settings.USE_TZ:
value = timezone.make_aware(value, timezone.get_current_timezone())
return value
|
'Get the lookup kwargs for filtering on a single date.
If the date field is a DateTimeField, we can\'t just filter on
date_field=date because that doesn\'t take the time into account.'
| def _make_single_date_lookup(self, date):
| date_field = self.get_date_field()
if self.uses_datetime_field:
since = self._make_date_lookup_arg(date)
until = self._make_date_lookup_arg((date + datetime.timedelta(days=1)))
return {(u'%s__gte' % date_field): since, (u'%s__lt' % date_field): until}
else:
return {date_field... |
'Obtain the list of dates and items.'
| def get_dated_items(self):
| raise NotImplementedError(u'A DateView must provide an implementation of get_dated_items()')
|
'Get a queryset properly filtered according to `allow_future` and any
extra lookup kwargs.'
| def get_dated_queryset(self, ordering=None, **lookup):
| qs = self.get_queryset().filter(**lookup)
date_field = self.get_date_field()
allow_future = self.get_allow_future()
allow_empty = self.get_allow_empty()
paginate_by = self.get_paginate_by(qs)
if (ordering is not None):
qs = qs.order_by(ordering)
if (not allow_future):
now = (... |
'Get the aggregation period for the list of dates: \'year\', \'month\', or \'day\'.'
| def get_date_list_period(self):
| return self.date_list_period
|
'Get a date list by calling `queryset.dates()`, checking along the way
for empty lists that aren\'t allowed.'
| def get_date_list(self, queryset, date_type=None, ordering=u'ASC'):
| date_field = self.get_date_field()
allow_empty = self.get_allow_empty()
if (date_type is None):
date_type = self.get_date_list_period()
date_list = queryset.dates(date_field, date_type, ordering)
if ((date_list is not None) and (not date_list) and (not allow_empty)):
name = force_tex... |
'Return (date_list, items, extra_context) for this request.'
| def get_dated_items(self):
| qs = self.get_dated_queryset(ordering=(u'-%s' % self.get_date_field()))
date_list = self.get_date_list(qs, ordering=u'DESC')
if (not date_list):
qs = qs.none()
return (date_list, qs, {})
|
'Return (date_list, items, extra_context) for this request.'
| def get_dated_items(self):
| year = self.get_year()
date_field = self.get_date_field()
date = _date_from_string(year, self.get_year_format())
since = self._make_date_lookup_arg(date)
until = self._make_date_lookup_arg(self._get_next_year(date))
lookup_kwargs = {(u'%s__gte' % date_field): since, (u'%s__lt' % date_field): unt... |
'Return `True` if this view should contain the full list of objects in
the given year.'
| def get_make_object_list(self):
| return self.make_object_list
|
'Return (date_list, items, extra_context) for this request.'
| def get_dated_items(self):
| year = self.get_year()
month = self.get_month()
date_field = self.get_date_field()
date = _date_from_string(year, self.get_year_format(), month, self.get_month_format())
since = self._make_date_lookup_arg(date)
until = self._make_date_lookup_arg(self._get_next_month(date))
lookup_kwargs = {(... |
'Return (date_list, items, extra_context) for this request.'
| def get_dated_items(self):
| year = self.get_year()
week = self.get_week()
date_field = self.get_date_field()
week_format = self.get_week_format()
week_start = {u'%W': u'1', u'%U': u'0'}[week_format]
date = _date_from_string(year, self.get_year_format(), week_start, u'%w', week, week_format)
since = self._make_date_look... |
'Return (date_list, items, extra_context) for this request.'
| def get_dated_items(self):
| year = self.get_year()
month = self.get_month()
day = self.get_day()
date = _date_from_string(year, self.get_year_format(), month, self.get_month_format(), day, self.get_day_format())
return self._get_dated_items(date)
|
'Do the actual heavy lifting of getting the dated items; this accepts a
date object so that TodayArchiveView can be trivial.'
| def _get_dated_items(self, date):
| lookup_kwargs = self._make_single_date_lookup(date)
qs = self.get_dated_queryset(**lookup_kwargs)
return (None, qs, {u'day': date, u'previous_day': self.get_previous_day(date), u'next_day': self.get_next_day(date), u'previous_month': self.get_previous_month(date), u'next_month': self.get_next_month(date)})
|
'Return (date_list, items, extra_context) for this request.'
| def get_dated_items(self):
| return self._get_dated_items(datetime.date.today())
|
'Get the object this request displays.'
| def get_object(self, queryset=None):
| year = self.get_year()
month = self.get_month()
day = self.get_day()
date = _date_from_string(year, self.get_year_format(), month, self.get_month_format(), day, self.get_day_format())
qs = (queryset or self.get_queryset())
if ((not self.get_allow_future()) and (date > datetime.date.today())):
... |
'Get the list of items for this view. This must be an iterable, and may
be a queryset (in which qs-specific behavior will be enabled).'
| def get_queryset(self):
| if (self.queryset is not None):
queryset = self.queryset
if hasattr(queryset, u'_clone'):
queryset = queryset._clone()
elif (self.model is not None):
queryset = self.model._default_manager.all()
else:
raise ImproperlyConfigured((u"'%s' must define 'querys... |
'Paginate the queryset, if needed.'
| def paginate_queryset(self, queryset, page_size):
| paginator = self.get_paginator(queryset, page_size, allow_empty_first_page=self.get_allow_empty())
page_kwarg = self.page_kwarg
page = (self.kwargs.get(page_kwarg) or self.request.GET.get(page_kwarg) or 1)
try:
page_number = int(page)
except ValueError:
if (page == u'last'):
... |
'Get the number of items to paginate by, or ``None`` for no pagination.'
| def get_paginate_by(self, queryset):
| return self.paginate_by
|
'Return an instance of the paginator for this view.'
| def get_paginator(self, queryset, per_page, orphans=0, allow_empty_first_page=True):
| return self.paginator_class(queryset, per_page, orphans=orphans, allow_empty_first_page=allow_empty_first_page)
|
'Returns ``True`` if the view should display empty lists, and ``False``
if a 404 should be raised instead.'
| def get_allow_empty(self):
| return self.allow_empty
|
'Get the name of the item to be used in the context.'
| def get_context_object_name(self, object_list):
| if self.context_object_name:
return self.context_object_name
elif hasattr(object_list, u'model'):
return (u'%s_list' % object_list.model._meta.object_name.lower())
else:
return None
|
'Get the context for this view.'
| def get_context_data(self, **kwargs):
| queryset = kwargs.pop(u'object_list')
page_size = self.get_paginate_by(queryset)
context_object_name = self.get_context_object_name(queryset)
if page_size:
(paginator, page, queryset, is_paginated) = self.paginate_queryset(queryset, page_size)
context = {u'paginator': paginator, u'page_o... |
'Return a list of template names to be used for the request. Must return
a list. May not be called if render_to_response is overridden.'
| def get_template_names(self):
| try:
names = super(MultipleObjectTemplateResponseMixin, self).get_template_names()
except ImproperlyConfigured:
names = []
if hasattr(self.object_list, u'model'):
opts = self.object_list.model._meta
names.append((u'%s/%s%s.html' % (opts.app_label, opts.object_name.lower(), se... |
'Returns the initial data to use for forms on this view.'
| def get_initial(self):
| return self.initial.copy()
|
'Returns the form class to use in this view'
| def get_form_class(self):
| return self.form_class
|
'Returns an instance of the form to be used in this view.'
| def get_form(self, form_class):
| return form_class(**self.get_form_kwargs())
|
'Returns the keyword arguments for instantiating the form.'
| def get_form_kwargs(self):
| kwargs = {'initial': self.get_initial()}
if (self.request.method in ('POST', 'PUT')):
kwargs.update({'data': self.request.POST, 'files': self.request.FILES})
return kwargs
|
'Returns the supplied success URL.'
| def get_success_url(self):
| if self.success_url:
url = force_text(self.success_url)
else:
raise ImproperlyConfigured('No URL to redirect to. Provide a success_url.')
return url
|
'If the form is valid, redirect to the supplied URL.'
| def form_valid(self, form):
| return HttpResponseRedirect(self.get_success_url())
|
'If the form is invalid, re-render the context data with the
data-filled form and errors.'
| def form_invalid(self, form):
| return self.render_to_response(self.get_context_data(form=form))
|
'Returns the form class to use in this view.'
| def get_form_class(self):
| if self.form_class:
return self.form_class
else:
if (self.model is not None):
model = self.model
elif (hasattr(self, 'object') and (self.object is not None)):
model = self.object.__class__
else:
model = self.get_queryset().model
return ... |
'Returns the keyword arguments for instantiating the form.'
| def get_form_kwargs(self):
| kwargs = super(ModelFormMixin, self).get_form_kwargs()
kwargs.update({'instance': self.object})
return kwargs
|
'Returns the supplied URL.'
| def get_success_url(self):
| if self.success_url:
url = (self.success_url % self.object.__dict__)
else:
try:
url = self.object.get_absolute_url()
except AttributeError:
raise ImproperlyConfigured('No URL to redirect to. Either provide a url or define a ... |
'If the form is valid, save the associated model.'
| def form_valid(self, form):
| self.object = form.save()
return super(ModelFormMixin, self).form_valid(form)
|
'If an object has been supplied, inject it into the context with the
supplied context_object_name name.'
| def get_context_data(self, **kwargs):
| context = {}
if self.object:
context['object'] = self.object
context_object_name = self.get_context_object_name(self.object)
if context_object_name:
context[context_object_name] = self.object
context.update(kwargs)
return super(ModelFormMixin, self).get_context_data(*... |
'Handles GET requests and instantiates a blank version of the form.'
| def get(self, request, *args, **kwargs):
| form_class = self.get_form_class()
form = self.get_form(form_class)
return self.render_to_response(self.get_context_data(form=form))
|
'Handles POST requests, instantiating a form instance with the passed
POST variables and then checked for validity.'
| def post(self, request, *args, **kwargs):
| form_class = self.get_form_class()
form = self.get_form(form_class)
if form.is_valid():
return self.form_valid(form)
else:
return self.form_invalid(form)
|
'Calls the delete() method on the fetched object and then
redirects to the success URL.'
| def delete(self, request, *args, **kwargs):
| self.object = self.get_object()
self.object.delete()
return HttpResponseRedirect(self.get_success_url())
|
'This filter is to add safety in production environments (i.e. DEBUG
is False). If DEBUG is True then your site is not safe anyway.
This hook is provided as a convenience to easily activate or
deactivate the filter on a per request basis.'
| def is_active(self, request):
| return (settings.DEBUG is False)
|
'Replaces the values of POST parameters marked as sensitive with
stars (*********).'
| def get_post_parameters(self, request):
| if (request is None):
return {}
else:
sensitive_post_parameters = getattr(request, u'sensitive_post_parameters', [])
if (self.is_active(request) and sensitive_post_parameters):
cleansed = request.POST.copy()
if (sensitive_post_parameters == u'__ALL__'):
... |
'Replaces the values of variables marked as sensitive with
stars (*********).'
| def get_traceback_frame_variables(self, request, tb_frame):
| current_frame = tb_frame.f_back
sensitive_variables = None
while (current_frame is not None):
if ((current_frame.f_code.co_name == u'sensitive_variables_wrapper') and (u'sensitive_variables_wrapper' in current_frame.f_locals)):
wrapper = current_frame.f_locals[u'sensitive_variables_wrapp... |
'Return a Context instance containing traceback information.'
| def get_traceback_data(self):
| if (self.exc_type and issubclass(self.exc_type, TemplateDoesNotExist)):
from django.template.loader import template_source_loaders
self.template_does_not_exist = True
self.loader_debug_info = []
for loader in template_source_loaders:
try:
source_list_func ... |
'Return HTML version of debug 500 HTTP error page.'
| def get_traceback_html(self):
| t = Template(TECHNICAL_500_TEMPLATE, name=u'Technical 500 template')
c = Context(self.get_traceback_data())
return t.render(c)
|
'Return plain text version of debug 500 HTTP error page.'
| def get_traceback_text(self):
| t = Template(TECHNICAL_500_TEXT_TEMPLATE, name=u'Technical 500 template')
c = Context(self.get_traceback_data(), autoescape=False)
return t.render(c)
|
'Returns context_lines before and after lineno from file.
Returns (pre_context_lineno, pre_context, context_line, post_context).'
| def _get_lines_from_file(self, filename, lineno, context_lines, loader=None, module_name=None):
| source = None
if ((loader is not None) and hasattr(loader, u'get_source')):
source = loader.get_source(module_name)
if (source is not None):
source = source.splitlines()
if (source is None):
try:
with open(filename, u'rb') as fp:
source = fp.re... |
'Return the same data as from traceback.format_exception.'
| def format_exception(self):
| import traceback
frames = self.get_traceback_frames()
tb = [(f[u'filename'], f[u'lineno'], f[u'function'], f[u'context_line']) for f in frames]
list = [u'Traceback (most recent call last):\n']
list += traceback.format_list(tb)
list += traceback.format_exception_only(self.exc_type, se... |
'Validates the given value and returns its "cleaned" value as an
appropriate Python object.
Raises ValidationError for any errors.'
| def clean(self, value):
| value = self.to_python(value)
self.validate(value)
self.run_validators(value)
return value
|
'Return the value that should be shown for this field on render of a
bound form, given the submitted POST data for the field and the initial
data, if any.
For most fields, this will simply be data; FileFields need to handle it
a bit differently.'
| def bound_data(self, data, initial):
| return data
|
'Given a Widget instance (*not* a Widget class), returns a dictionary of
any HTML attributes that should be added to the Widget, based on this
Field.'
| def widget_attrs(self, widget):
| return {}
|
'Returns a Unicode object.'
| def to_python(self, value):
| if (value in validators.EMPTY_VALUES):
return u''
return smart_text(value)
|
'Validates that int() can be called on the input. Returns the result
of int(). Returns None for empty values.'
| def to_python(self, value):
| value = super(IntegerField, self).to_python(value)
if (value in validators.EMPTY_VALUES):
return None
if self.localize:
value = formats.sanitize_separators(value)
try:
value = int(str(value))
except (ValueError, TypeError):
raise ValidationError(self.error_messages[u'... |
'Validates that float() can be called on the input. Returns the result
of float(). Returns None for empty values.'
| def to_python(self, value):
| value = super(IntegerField, self).to_python(value)
if (value in validators.EMPTY_VALUES):
return None
if self.localize:
value = formats.sanitize_separators(value)
try:
value = float(value)
except (ValueError, TypeError):
raise ValidationError(self.error_messages[u'inv... |
'Validates that the input is a decimal number. Returns a Decimal
instance. Returns None for empty values. Ensures that there are no more
than max_digits in the number, and no more than decimal_places digits
after the decimal point.'
| def to_python(self, value):
| if (value in validators.EMPTY_VALUES):
return None
if self.localize:
value = formats.sanitize_separators(value)
value = smart_text(value).strip()
try:
value = Decimal(value)
except DecimalException:
raise ValidationError(self.error_messages[u'invalid'])
return val... |
'Validates that the input can be converted to a date. Returns a Python
datetime.date object.'
| def to_python(self, value):
| if (value in validators.EMPTY_VALUES):
return None
if isinstance(value, datetime.datetime):
return value.date()
if isinstance(value, datetime.date):
return value
return super(DateField, self).to_python(value)
|
'Validates that the input can be converted to a time. Returns a Python
datetime.time object.'
| def to_python(self, value):
| if (value in validators.EMPTY_VALUES):
return None
if isinstance(value, datetime.time):
return value
return super(TimeField, self).to_python(value)
|
'Validates that the input can be converted to a datetime. Returns a
Python datetime.datetime object.'
| def to_python(self, value):
| if (value in validators.EMPTY_VALUES):
return None
if isinstance(value, datetime.datetime):
return from_current_timezone(value)
if isinstance(value, datetime.date):
result = datetime.datetime(value.year, value.month, value.day)
return from_current_timezone(result)
if isin... |
'regex can be either a string or a compiled regular expression object.
error_message is an optional error message to use, if
\'Enter a valid value\' is too generic for you.'
| def __init__(self, regex, max_length=None, min_length=None, error_message=None, *args, **kwargs):
| if error_message:
error_messages = (kwargs.get(u'error_messages') or {})
error_messages[u'invalid'] = error_message
kwargs[u'error_messages'] = error_messages
super(RegexField, self).__init__(max_length, min_length, *args, **kwargs)
self._set_regex(regex)
|
'Checks that the file-upload field data contains a valid image (GIF, JPG,
PNG, possibly others -- whatever the Python Imaging Library supports).'
| def to_python(self, data):
| f = super(ImageField, self).to_python(data)
if (f is None):
return None
try:
from PIL import Image
except ImportError:
import Image
if hasattr(data, u'temporary_file_path'):
file = data.temporary_file_path()
elif hasattr(data, u'read'):
file = BytesIO(data... |
'Returns a Python boolean object.'
| def to_python(self, value):
| if (isinstance(value, six.string_types) and (value.lower() in (u'false', u'0'))):
value = False
else:
value = bool(value)
value = super(BooleanField, self).to_python(value)
if ((not value) and self.required):
raise ValidationError(self.error_messages[u'required'])
return valu... |
'Explicitly checks for the string \'True\' and \'False\', which is what a
hidden field will submit for True and False, and for \'1\' and \'0\', which
is what a RadioField will submit. Unlike the Booleanfield we need to
explicitly check for True, because we are not using the bool() function'
| def to_python(self, value):
| if (value in (True, u'True', u'1')):
return True
elif (value in (False, u'False', u'0')):
return False
else:
return None
|
'Returns a Unicode object.'
| def to_python(self, value):
| if (value in validators.EMPTY_VALUES):
return u''
return smart_text(value)
|
'Validates that the input is in self.choices.'
| def validate(self, value):
| super(ChoiceField, self).validate(value)
if (value and (not self.valid_value(value))):
raise ValidationError((self.error_messages[u'invalid_choice'] % {u'value': value}))
|
'Check to see if the provided value is a valid choice'
| def valid_value(self, value):
| for (k, v) in self.choices:
if isinstance(v, (list, tuple)):
for (k2, v2) in v:
if (value == smart_text(k2)):
return True
elif (value == smart_text(k)):
return True
return False
|
'Validates that the value is in self.choices and can be coerced to the
right type.'
| def to_python(self, value):
| value = super(TypedChoiceField, self).to_python(value)
super(TypedChoiceField, self).validate(value)
if ((value == self.empty_value) or (value in validators.EMPTY_VALUES)):
return self.empty_value
try:
value = self.coerce(value)
except (ValueError, TypeError, ValidationError):
... |
'Validates that the input is a list or tuple.'
| def validate(self, value):
| if (self.required and (not value)):
raise ValidationError(self.error_messages[u'required'])
for val in value:
if (not self.valid_value(val)):
raise ValidationError((self.error_messages[u'invalid_choice'] % {u'value': val}))
|
'Validates that the values are in self.choices and can be coerced to the
right type.'
| def to_python(self, value):
| value = super(TypedMultipleChoiceField, self).to_python(value)
super(TypedMultipleChoiceField, self).validate(value)
if ((value == self.empty_value) or (value in validators.EMPTY_VALUES)):
return self.empty_value
new_value = []
for choice in value:
try:
new_value.append(s... |
'Validates the given value against all of self.fields, which is a
list of Field instances.'
| def clean(self, value):
| super(ComboField, self).clean(value)
for field in self.fields:
value = field.clean(value)
return value
|
'Validates every value in the given list. A value is validated against
the corresponding Field in self.fields.
For example, if this MultiValueField was instantiated with
fields=(DateField(), TimeField()), clean() would call
DateField.clean(value[0]) and TimeField.clean(value[1]).'
| def clean(self, value):
| clean_data = []
errors = ErrorList()
if ((not value) or isinstance(value, (list, tuple))):
if ((not value) or (not [v for v in value if (v not in validators.EMPTY_VALUES)])):
if self.required:
raise ValidationError(self.error_messages[u'required'])
else:
... |
'Returns a single value for the given list of values. The values can be
assumed to be valid.
For example, if this MultiValueField was instantiated with
fields=(DateField(), TimeField()), this might return a datetime
object created by combining the date and time in data_list.'
| def compress(self, data_list):
| raise NotImplementedError(u'Subclasses must implement this method.')
|
'Yields the forms in the order they should be rendered'
| def __iter__(self):
| return iter(self.forms)
|
'Returns the form at the given index, based on the rendering order'
| def __getitem__(self, index):
| return self.forms[index]
|
'All formsets have a management form which is not included in the length'
| def __bool__(self):
| return True
|
'Returns the ManagementForm instance for this FormSet.'
| @property
def management_form(self):
| if self.is_bound:
form = ManagementForm(self.data, auto_id=self.auto_id, prefix=self.prefix)
if (not form.is_valid()):
raise ValidationError(u'ManagementForm data is missing or has been tampered with')
else:
form = ManagementForm(auto_id=self.auto_id, ... |
'Returns the total number of forms in this FormSet.'
| def total_form_count(self):
| if self.is_bound:
return self.management_form.cleaned_data[TOTAL_FORM_COUNT]
else:
initial_forms = self.initial_form_count()
total_forms = (initial_forms + self.extra)
if (initial_forms > self.max_num >= 0):
total_forms = initial_forms
elif (total_forms > self... |
'Returns the number of forms that are required in this FormSet.'
| def initial_form_count(self):
| if self.is_bound:
return self.management_form.cleaned_data[INITIAL_FORM_COUNT]
else:
initial_forms = ((self.initial and len(self.initial)) or 0)
if (initial_forms > self.max_num >= 0):
initial_forms = self.max_num
return initial_forms
|
'Instantiates and returns the i-th form instance in a formset.'
| def _construct_form(self, i, **kwargs):
| defaults = {u'auto_id': self.auto_id, u'prefix': self.add_prefix(i), u'error_class': self.error_class}
if self.is_bound:
defaults[u'data'] = self.data
defaults[u'files'] = self.files
if (self.initial and (not (u'initial' in kwargs))):
try:
defaults[u'initial'] = self.init... |
'Return a list of all the initial forms in this formset.'
| @property
def initial_forms(self):
| return self.forms[:self.initial_form_count()]
|
'Return a list of all the extra forms in this formset.'
| @property
def extra_forms(self):
| return self.forms[self.initial_form_count():]
|
'Returns a list of form.cleaned_data dicts for every form in self.forms.'
| @property
def cleaned_data(self):
| if (not self.is_valid()):
raise AttributeError((u"'%s' object has no attribute 'cleaned_data'" % self.__class__.__name__))
return [form.cleaned_data for form in self.forms]
|
'Returns a list of forms that have been marked for deletion. Raises an
AttributeError if deletion is not allowed.'
| @property
def deleted_forms(self):
| if ((not self.is_valid()) or (not self.can_delete)):
raise AttributeError((u"'%s' object has no attribute 'deleted_forms'" % self.__class__.__name__))
if (not hasattr(self, u'_deleted_form_indexes')):
self._deleted_form_indexes = []
for i in range(0, self.total_form_count(... |
'Returns a list of form in the order specified by the incoming data.
Raises an AttributeError if ordering is not allowed.'
| @property
def ordered_forms(self):
| if ((not self.is_valid()) or (not self.can_order)):
raise AttributeError((u"'%s' object has no attribute 'ordered_forms'" % self.__class__.__name__))
if (not hasattr(self, u'_ordering')):
self._ordering = []
for i in range(0, self.total_form_count()):
form = se... |
'Returns an ErrorList of errors that aren\'t associated with a particular
form -- i.e., from formset.clean(). Returns an empty ErrorList if there
are none.'
| def non_form_errors(self):
| if (self._non_form_errors is not None):
return self._non_form_errors
return self.error_class()
|
'Returns a list of form.errors for every form in self.forms.'
| @property
def errors(self):
| if (self._errors is None):
self.full_clean()
return self._errors
|
'Returns whether or not the form was marked for deletion.'
| def _should_delete_form(self, form):
| return form.cleaned_data.get(DELETION_FIELD_NAME, False)
|
'Returns True if every form in self.forms is valid.'
| def is_valid(self):
| if (not self.is_bound):
return False
forms_valid = True
err = self.errors
for i in range(0, self.total_form_count()):
form = self.forms[i]
if self.can_delete:
if self._should_delete_form(form):
continue
forms_valid &= form.is_valid()
return... |
'Cleans all of self.data and populates self._errors.'
| def full_clean(self):
| self._errors = []
if (not self.is_bound):
return
for i in range(0, self.total_form_count()):
form = self.forms[i]
self._errors.append(form.errors)
try:
self.clean()
except ValidationError as e:
self._non_form_errors = self.error_class(e.messages)
|
'Hook for doing any extra formset-wide cleaning after Form.clean() has
been called on every form. Any ValidationError raised by this method
will not be associated with a particular form; it will be accesible
via formset.non_form_errors()'
| def clean(self):
| pass
|
'Returns true if data in any form differs from initial.'
| def has_changed(self):
| return any((form.has_changed() for form in self))
|
'A hook for adding extra fields on to each form instance.'
| def add_fields(self, form, index):
| if self.can_order:
if ((index is not None) and (index < self.initial_form_count())):
form.fields[ORDERING_FIELD_NAME] = IntegerField(label=_(u'Order'), initial=(index + 1), required=False)
else:
form.fields[ORDERING_FIELD_NAME] = IntegerField(label=_(u'Order'), required=False... |
'Returns True if the formset needs to be multipart, i.e. it
has FileInput. Otherwise, False.'
| def is_multipart(self):
| if self.forms:
return self.forms[0].is_multipart()
else:
return self.empty_form.is_multipart()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.