def decorator(*args, **kwargs):
val = func(*args, **kwargs)
if not ins(val):
raise TypeError
for e in val:
if not ins(e) or len(e) != 2:
raise TypeError
return tuple(val)
def _clean_value(self, field, value, **kwargs):
formfield = None
# has highest precedence if defined on the class. this is usually NOT
# necessary
if self.formfield:
formfield = self.formfield
# special case for handling standalone ``None`` or ``bool`` values.
# this occurs when a field is can be queried as a null value, i.e.
# '-?isnull' : (True|False) or '-?exact' : None
elif value is None or type(value) is bool:
formfield = forms.NullBooleanField
# create an instance of the formfield "to be" and determine if there is
# a mapping listed for it. TODO make more elegant
else:
formfield = field.formfield
if formfield() is None:
name = field.field.__class__.__name__
else:
name = formfield().__class__.__name__
if self.formfield_overrides.has_key(name):
formfield = self.formfield_overrides[name]
# TODO since None is considered an empty value by the django validators
# ``required`` has to be set to False to not raise a ValidationError
# saying the field is required. There may be a need to more explicitly
# check to see if the value be passed is only None and not any of the
# other empty values in ``django.core.validators.EMPTY_VALUES``
ff = field.formfield(formfield=formfield, required=False, **kwargs)
# special case for ``None`` values since all form fields seem to handle
# the conversion differently. simply ignore the cleaning if ``None``,
# this scenario occurs when a list of values are being queried and one
# of them is to lookup NULL values
if ins(value):
new_value = []
unique_values = set([])
for x in value:
if x in unique_values:
continue
unique_values.add(x)
if x is not None:
new_value.append(ff.clean(x))
# Django assumes an empty string when given a ``NoneType``
# for char-based form fields, this is to ensure ``NoneType``
# are passed through unmodified
else:
new_value.append(None)
return new_value
return ff.clean(value)
def format_seq(self, seq, rules, ftype, formatters, error, null):
n, toks = 0, []
for fname, nargs in rules:
args = seq[n:n+nargs]
# if the formatter expects one argument, but it is None,
# skip the formatting and default to None.
if len(args) == 1 and args[0] is None:
tok = None
else:
try:
obj = formatters[fname]
tok = obj(ftype, *args)
except Exception:
tok = error
if ins(tok):
tok = list(tok)
for i, t in enumerate(iter(tok)):
if t is None:
tok[i] = null
toks.extend(tok)
else:
if tok is None:
tok = null
toks.append(tok)
n += nargs
# all args have not been processed, therefore mixed formatting may have
# occurred.
if n != len(seq):
raise FormatError, 'The rules "%s" is being applied to a ' \
'sequence of %d items' % (rules, len(seq))
return tuple(toks)
def check(self, value):
if ins(value):
return True
return False
def check(self, value):
if ins(value) and len(value) == 2:
return True
return False
