py_tasks_melange: comparison app/django/forms/fields.py

equal deleted inserted replaced

-:6641e941ef1e
+:ff1a9aa48cfd
+"""
+Field classes.
+"""
+import copy
+import datetime
+import os
+import re
+import time
+import urlparse
+try:
+from cStringIO import StringIO
+except ImportError:
+from StringIO import StringIO
+# Python 2.3 fallbacks
+try:
+from decimal import Decimal, DecimalException
+except ImportError:
+from django.utils._decimal import Decimal, DecimalException
+try:
+set
+except NameError:
+from sets import Set as set
+import django.core.exceptions
+from django.utils.translation import ugettext_lazy as _
+from django.utils.encoding import smart_unicode, smart_str
+from util import ErrorList, ValidationError
+from widgets import TextInput, PasswordInput, HiddenInput, MultipleHiddenInput, FileInput, CheckboxInput, Select, NullBooleanSelect, SelectMultiple, DateTimeInput, TimeInput, SplitHiddenDateTimeWidget
+from django.core.files.uploadedfile import SimpleUploadedFile as UploadedFile
+__all__ = (
+'Field', 'CharField', 'IntegerField',
+'DEFAULT_DATE_INPUT_FORMATS', 'DateField',
+'DEFAULT_TIME_INPUT_FORMATS', 'TimeField',
+'DEFAULT_DATETIME_INPUT_FORMATS', 'DateTimeField', 'TimeField',
+'RegexField', 'EmailField', 'FileField', 'ImageField', 'URLField',
+'BooleanField', 'NullBooleanField', 'ChoiceField', 'MultipleChoiceField',
+'ComboField', 'MultiValueField', 'FloatField', 'DecimalField',
+'SplitDateTimeField', 'IPAddressField', 'FilePathField', 'SlugField',
+'TypedChoiceField'
+)
+# These values, if given to to_python(), will trigger the self.required check.
+EMPTY_VALUES = (None, '')
+class Field(object):
+widget = TextInput # Default widget to use when rendering this type of Field.
+hidden_widget = HiddenInput # Default widget to use when rendering this as "hidden".
+default_error_messages = {
+'required': _(u'This field is required.'),
+'invalid': _(u'Enter a valid value.'),
+}
+# Tracks each time a Field instance is created. Used to retain order.
+creation_counter = 0
+def __init__(self, required=True, widget=None, label=None, initial=None,
+help_text=None, error_messages=None, show_hidden_initial=False):
+# required -- Boolean that specifies whether the field is required.
+#             True by default.
+# widget -- A Widget class, or instance of a Widget class, that should
+#           be used for this Field when displaying it. Each Field has a
+#           default Widget that it'll use if you don't specify this. In
+#           most cases, the default widget is TextInput.
+# label -- A verbose name for this field, for use in displaying this
+#          field in a form. By default, Django will use a "pretty"
+#          version of the form field name, if the Field is part of a
+#          Form.
+# initial -- A value to use in this Field's initial display. This value
+#            is *not* used as a fallback if data isn't given.
+# help_text -- An optional string to use as "help text" for this Field.
+# show_hidden_initial -- Boolean that specifies if it is needed to render a
+#                        hidden widget with initial value after widget.
+if label is not None:
+label = smart_unicode(label)
+self.required, self.label, self.initial = required, label, initial
+self.show_hidden_initial = show_hidden_initial
+if help_text is None:
+self.help_text = u''
+else:
+self.help_text = smart_unicode(help_text)
+widget = widget or self.widget
+if isinstance(widget, type):
+widget = widget()
+# Hook into self.widget_attrs() for any Field-specific HTML attributes.
+extra_attrs = self.widget_attrs(widget)
+if extra_attrs:
+widget.attrs.update(extra_attrs)
+self.widget = widget
+# Increase the creation counter, and save our local copy.
+self.creation_counter = Field.creation_counter
+Field.creation_counter += 1
+def set_class_error_messages(messages, klass):
+for base_class in klass.__bases__:
+set_class_error_messages(messages, base_class)
+messages.update(getattr(klass, 'default_error_messages', {}))
+messages = {}
+set_class_error_messages(messages, self.__class__)
+messages.update(error_messages or {})
+self.error_messages = messages
+def clean(self, value):
+"""
+Validates the given value and returns its "cleaned" value as an
+appropriate Python object.
+Raises ValidationError for any errors.
+"""
+if self.required and value in EMPTY_VALUES:
+raise ValidationError(self.error_messages['required'])
+return value
+def widget_attrs(self, widget):
+"""
+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.
+"""
+return {}
+def __deepcopy__(self, memo):
+result = copy.copy(self)
+memo[id(self)] = result
+result.widget = copy.deepcopy(self.widget, memo)
+return result
+class CharField(Field):
+default_error_messages = {
+'max_length': _(u'Ensure this value has at most %(max)d characters (it has %(length)d).'),
+'min_length': _(u'Ensure this value has at least %(min)d characters (it has %(length)d).'),
+}
+def __init__(self, max_length=None, min_length=None, *args, **kwargs):
+self.max_length, self.min_length = max_length, min_length
+super(CharField, self).__init__(*args, **kwargs)
+def clean(self, value):
+"Validates max_length and min_length. Returns a Unicode object."
+super(CharField, self).clean(value)
+if value in EMPTY_VALUES:
+return u''
+value = smart_unicode(value)
+value_length = len(value)
+if self.max_length is not None and value_length > self.max_length:
+raise ValidationError(self.error_messages['max_length'] % {'max': self.max_length, 'length': value_length})
+if self.min_length is not None and value_length < self.min_length:
+raise ValidationError(self.error_messages['min_length'] % {'min': self.min_length, 'length': value_length})
+return value
+def widget_attrs(self, widget):
+if self.max_length is not None and isinstance(widget, (TextInput, PasswordInput)):
+# The HTML attribute is maxlength, not max_length.
+return {'maxlength': str(self.max_length)}
+class IntegerField(Field):
+default_error_messages = {
+'invalid': _(u'Enter a whole number.'),
+'max_value': _(u'Ensure this value is less than or equal to %s.'),
+'min_value': _(u'Ensure this value is greater than or equal to %s.'),
+}
+def __init__(self, max_value=None, min_value=None, *args, **kwargs):
+self.max_value, self.min_value = max_value, min_value
+super(IntegerField, self).__init__(*args, **kwargs)
+def clean(self, value):
+"""
+Validates that int() can be called on the input. Returns the result
+of int(). Returns None for empty values.
+"""
+super(IntegerField, self).clean(value)
+if value in EMPTY_VALUES:
+return None
+try:
+value = int(str(value))
+except (ValueError, TypeError):
+raise ValidationError(self.error_messages['invalid'])
+if self.max_value is not None and value > self.max_value:
+raise ValidationError(self.error_messages['max_value'] % self.max_value)
+if self.min_value is not None and value < self.min_value:
+raise ValidationError(self.error_messages['min_value'] % self.min_value)
+return value
+class FloatField(Field):
+default_error_messages = {
+'invalid': _(u'Enter a number.'),
+'max_value': _(u'Ensure this value is less than or equal to %s.'),
+'min_value': _(u'Ensure this value is greater than or equal to %s.'),
+}
+def __init__(self, max_value=None, min_value=None, *args, **kwargs):
+self.max_value, self.min_value = max_value, min_value
+Field.__init__(self, *args, **kwargs)
+def clean(self, value):
+"""
+Validates that float() can be called on the input. Returns a float.
+Returns None for empty values.
+"""
+super(FloatField, self).clean(value)
+if not self.required and value in EMPTY_VALUES:
+return None
+try:
+value = float(value)
+except (ValueError, TypeError):
+raise ValidationError(self.error_messages['invalid'])
+if self.max_value is not None and value > self.max_value:
+raise ValidationError(self.error_messages['max_value'] % self.max_value)
+if self.min_value is not None and value < self.min_value:
+raise ValidationError(self.error_messages['min_value'] % self.min_value)
+return value
+class DecimalField(Field):
+default_error_messages = {
+'invalid': _(u'Enter a number.'),
+'max_value': _(u'Ensure this value is less than or equal to %s.'),
+'min_value': _(u'Ensure this value is greater than or equal to %s.'),
+'max_digits': _('Ensure that there are no more than %s digits in total.'),
+'max_decimal_places': _('Ensure that there are no more than %s decimal places.'),
+'max_whole_digits': _('Ensure that there are no more than %s digits before the decimal point.')
+}
+def __init__(self, max_value=None, min_value=None, max_digits=None, decimal_places=None, *args, **kwargs):
+self.max_value, self.min_value = max_value, min_value
+self.max_digits, self.decimal_places = max_digits, decimal_places
+Field.__init__(self, *args, **kwargs)
+def clean(self, value):
+"""
+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.
+"""
+super(DecimalField, self).clean(value)
+if not self.required and value in EMPTY_VALUES:
+return None
+value = smart_str(value).strip()
+try:
+value = Decimal(value)
+except DecimalException:
+raise ValidationError(self.error_messages['invalid'])
+sign, digittuple, exponent = value.as_tuple()
+decimals = abs(exponent)
+# digittuple doesn't include any leading zeros.
+digits = len(digittuple)
+if decimals >= digits:
+# We have leading zeros up to or past the decimal point.  Count
+# everything past the decimal point as a digit.  We also add one
+# for leading zeros before the decimal point (any number of leading
+# whole zeros collapse to one digit).
+digits = decimals + 1
+whole_digits = digits - decimals
+if self.max_value is not None and value > self.max_value:
+raise ValidationError(self.error_messages['max_value'] % self.max_value)
+if self.min_value is not None and value < self.min_value:
+raise ValidationError(self.error_messages['min_value'] % self.min_value)
+if self.max_digits is not None and digits > self.max_digits:
+raise ValidationError(self.error_messages['max_digits'] % self.max_digits)
+if self.decimal_places is not None and decimals > self.decimal_places:
+raise ValidationError(self.error_messages['max_decimal_places'] % self.decimal_places)
+if self.max_digits is not None and self.decimal_places is not None and whole_digits > (self.max_digits - self.decimal_places):
+raise ValidationError(self.error_messages['max_whole_digits'] % (self.max_digits - self.decimal_places))
+return value
+DEFAULT_DATE_INPUT_FORMATS = (
+'%Y-%m-%d', '%m/%d/%Y', '%m/%d/%y', # '2006-10-25', '10/25/2006', '10/25/06'
+'%b %d %Y', '%b %d, %Y',            # 'Oct 25 2006', 'Oct 25, 2006'
+'%d %b %Y', '%d %b, %Y',            # '25 Oct 2006', '25 Oct, 2006'
+'%B %d %Y', '%B %d, %Y',            # 'October 25 2006', 'October 25, 2006'
+'%d %B %Y', '%d %B, %Y',            # '25 October 2006', '25 October, 2006'
+)
+class DateField(Field):
+default_error_messages = {
+'invalid': _(u'Enter a valid date.'),
+}
+def __init__(self, input_formats=None, *args, **kwargs):
+super(DateField, self).__init__(*args, **kwargs)
+self.input_formats = input_formats or DEFAULT_DATE_INPUT_FORMATS
+def clean(self, value):
+"""
+Validates that the input can be converted to a date. Returns a Python
+datetime.date object.
+"""
+super(DateField, self).clean(value)
+if value in EMPTY_VALUES:
+return None
+if isinstance(value, datetime.datetime):
+return value.date()
+if isinstance(value, datetime.date):
+return value
+for format in self.input_formats:
+try:
+return datetime.date(*time.strptime(value, format)[:3])
+except ValueError:
+continue
+raise ValidationError(self.error_messages['invalid'])
+DEFAULT_TIME_INPUT_FORMATS = (
+'%H:%M:%S',     # '14:30:59'
+'%H:%M',        # '14:30'
+)
+class TimeField(Field):
+widget = TimeInput
+default_error_messages = {
+'invalid': _(u'Enter a valid time.')
+}
+def __init__(self, input_formats=None, *args, **kwargs):
+super(TimeField, self).__init__(*args, **kwargs)
+self.input_formats = input_formats or DEFAULT_TIME_INPUT_FORMATS
+def clean(self, value):
+"""
+Validates that the input can be converted to a time. Returns a Python
+datetime.time object.
+"""
+super(TimeField, self).clean(value)
+if value in EMPTY_VALUES:
+return None
+if isinstance(value, datetime.time):
+return value
+for format in self.input_formats:
+try:
+return datetime.time(*time.strptime(value, format)[3:6])
+except ValueError:
+continue
+raise ValidationError(self.error_messages['invalid'])
+DEFAULT_DATETIME_INPUT_FORMATS = (
+'%Y-%m-%d %H:%M:%S',     # '2006-10-25 14:30:59'
+'%Y-%m-%d %H:%M',        # '2006-10-25 14:30'
+'%Y-%m-%d',              # '2006-10-25'
+'%m/%d/%Y %H:%M:%S',     # '10/25/2006 14:30:59'
+'%m/%d/%Y %H:%M',        # '10/25/2006 14:30'
+'%m/%d/%Y',              # '10/25/2006'
+'%m/%d/%y %H:%M:%S',     # '10/25/06 14:30:59'
+'%m/%d/%y %H:%M',        # '10/25/06 14:30'
+'%m/%d/%y',              # '10/25/06'
+)
+class DateTimeField(Field):
+widget = DateTimeInput
+default_error_messages = {
+'invalid': _(u'Enter a valid date/time.'),
+}
+def __init__(self, input_formats=None, *args, **kwargs):
+super(DateTimeField, self).__init__(*args, **kwargs)
+self.input_formats = input_formats or DEFAULT_DATETIME_INPUT_FORMATS
+def clean(self, value):
+"""
+Validates that the input can be converted to a datetime. Returns a
+Python datetime.datetime object.
+"""
+super(DateTimeField, self).clean(value)
+if value in EMPTY_VALUES:
+return None
+if isinstance(value, datetime.datetime):
+return value
+if isinstance(value, datetime.date):
+return datetime.datetime(value.year, value.month, value.day)
+if isinstance(value, list):
+# Input comes from a SplitDateTimeWidget, for example. So, it's two
+# components: date and time.
+if len(value) != 2:
+raise ValidationError(self.error_messages['invalid'])
+value = '%s %s' % tuple(value)
+for format in self.input_formats:
+try:
+return datetime.datetime(*time.strptime(value, format)[:6])
+except ValueError:
+continue
+raise ValidationError(self.error_messages['invalid'])
+class RegexField(CharField):
+def __init__(self, regex, max_length=None, min_length=None, error_message=None, *args, **kwargs):
+"""
+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.
+"""
+# error_message is just kept for backwards compatibility:
+if error_message:
+error_messages = kwargs.get('error_messages') or {}
+error_messages['invalid'] = error_message
+kwargs['error_messages'] = error_messages
+super(RegexField, self).__init__(max_length, min_length, *args, **kwargs)
+if isinstance(regex, basestring):
+regex = re.compile(regex)
+self.regex = regex
+def clean(self, value):
+"""
+Validates that the input matches the regular expression. Returns a
+Unicode object.
+"""
+value = super(RegexField, self).clean(value)
+if value == u'':
+return value
+if not self.regex.search(value):
+raise ValidationError(self.error_messages['invalid'])
+return value
+email_re = re.compile(
+r"(^[-!#$%&'*+/=?^_`{}|~0-9A-Z]+(\.[-!#$%&'*+/=?^_`{}|~0-9A-Z]+)*"  # dot-atom
+r'|^"([\001-\010\013\014\016-\037!#-\[\]-\177]|\\[\001-011\013\014\016-\177])*"' # quoted-string
+r')@(?:[A-Z0-9-]+\.)+[A-Z]{2,6}$', re.IGNORECASE)  # domain
+class EmailField(RegexField):
+default_error_messages = {
+'invalid': _(u'Enter a valid e-mail address.'),
+}
+def __init__(self, max_length=None, min_length=None, *args, **kwargs):
+RegexField.__init__(self, email_re, max_length, min_length, *args,
+**kwargs)
+try:
+from django.conf import settings
+URL_VALIDATOR_USER_AGENT = settings.URL_VALIDATOR_USER_AGENT
+except ImportError:
+# It's OK if Django settings aren't configured.
+URL_VALIDATOR_USER_AGENT = 'Django (http://www.djangoproject.com/)'
+class FileField(Field):
+widget = FileInput
+default_error_messages = {
+'invalid': _(u"No file was submitted. Check the encoding type on the form."),
+'missing': _(u"No file was submitted."),
+'empty': _(u"The submitted file is empty."),
+}
+def __init__(self, *args, **kwargs):
+super(FileField, self).__init__(*args, **kwargs)
+def clean(self, data, initial=None):
+super(FileField, self).clean(initial or data)
+if not self.required and data in EMPTY_VALUES:
+return None
+elif not data and initial:
+return initial
+# UploadedFile objects should have name and size attributes.
+try:
+file_name = data.name
+file_size = data.size
+except AttributeError:
+raise ValidationError(self.error_messages['invalid'])
+if not file_name:
+raise ValidationError(self.error_messages['invalid'])
+if not file_size:
+raise ValidationError(self.error_messages['empty'])
+return data
+class ImageField(FileField):
+default_error_messages = {
+'invalid_image': _(u"Upload a valid image. The file you uploaded was either not an image or a corrupted image."),
+}
+def clean(self, data, initial=None):
+"""
+Checks that the file-upload field data contains a valid image (GIF, JPG,
+PNG, possibly others -- whatever the Python Imaging Library supports).
+"""
+f = super(ImageField, self).clean(data, initial)
+if f is None:
+return None
+elif not data and initial:
+return initial
+from PIL import Image
+# We need to get a file object for PIL. We might have a path or we might
+# have to read the data into memory.
+if hasattr(data, 'temporary_file_path'):
+file = data.temporary_file_path()
+else:
+if hasattr(data, 'read'):
+file = StringIO(data.read())
+else:
+file = StringIO(data['content'])
+try:
+# load() is the only method that can spot a truncated JPEG,
+#  but it cannot be called sanely after verify()
+trial_image = Image.open(file)
+trial_image.load()
+# Since we're about to use the file again we have to reset the
+# file object if possible.
+if hasattr(file, 'reset'):
+file.reset()
+# verify() is the only method that can spot a corrupt PNG,
+#  but it must be called immediately after the constructor
+trial_image = Image.open(file)
+trial_image.verify()
+except ImportError:
+# Under PyPy, it is possible to import PIL. However, the underlying
+# _imaging C module isn't available, so an ImportError will be
+# raised. Catch and re-raise.
+raise
+except Exception: # Python Imaging Library doesn't recognize it as an image
+raise ValidationError(self.error_messages['invalid_image'])
+if hasattr(f, 'seek') and callable(f.seek):
+f.seek(0)
+return f
+url_re = re.compile(
+r'^https?://' # http:// or https://
+r'(?:(?:[A-Z0-9-]+\.)+[A-Z]{2,6}|' #domain...
+r'localhost|' #localhost...
+r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})' # ...or ip
+r'(?::\d+)?' # optional port
+r'(?:/?|/\S+)$', re.IGNORECASE)
+class URLField(RegexField):
+default_error_messages = {
+'invalid': _(u'Enter a valid URL.'),
+'invalid_link': _(u'This URL appears to be a broken link.'),
+}
+def __init__(self, max_length=None, min_length=None, verify_exists=False,
+validator_user_agent=URL_VALIDATOR_USER_AGENT, *args, **kwargs):
+super(URLField, self).__init__(url_re, max_length, min_length, *args,
+**kwargs)
+self.verify_exists = verify_exists
+self.user_agent = validator_user_agent
+def clean(self, value):
+# If no URL scheme given, assume http://
+if value and '://' not in value:
+value = u'http://%s' % value
+# If no URL path given, assume /
+if value and not urlparse.urlsplit(value)[2]:
+value += '/'
+value = super(URLField, self).clean(value)
+if value == u'':
+return value
+if self.verify_exists:
+import urllib2
+headers = {
+"Accept": "text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5",
+"Accept-Language": "en-us,en;q=0.5",
+"Accept-Charset": "ISO-8859-1,utf-8;q=0.7,*;q=0.7",
+"Connection": "close",
+"User-Agent": self.user_agent,
+}
+try:
+req = urllib2.Request(value, None, headers)
+u = urllib2.urlopen(req)
+except ValueError:
+raise ValidationError(self.error_messages['invalid'])
+except: # urllib2.URLError, httplib.InvalidURL, etc.
+raise ValidationError(self.error_messages['invalid_link'])
+return value
+class BooleanField(Field):
+widget = CheckboxInput
+def clean(self, value):
+"""Returns a Python boolean object."""
+# Explicitly check for the string 'False', which is what a hidden field
+# will submit for False. Because bool("True") == True, we don't need to
+# handle that explicitly.
+if value == 'False':
+value = False
+else:
+value = bool(value)
+super(BooleanField, self).clean(value)
+if not value and self.required:
+raise ValidationError(self.error_messages['required'])
+return value
+class NullBooleanField(BooleanField):
+"""
+A field whose valid values are None, True and False. Invalid values are
+cleaned to None.
+"""
+widget = NullBooleanSelect
+def clean(self, value):
+"""
+Explicitly checks for the string 'True' and 'False', which is what a
+hidden field will submit for True and False. Unlike the
+Booleanfield we also need to check for True, because we are not using
+the bool() function
+"""
+if value in (True, 'True'):
+return True
+elif value in (False, 'False'):
+return False
+else:
+return None
+class ChoiceField(Field):
+widget = Select
+default_error_messages = {
+'invalid_choice': _(u'Select a valid choice. %(value)s is not one of the available choices.'),
+}
+def __init__(self, choices=(), required=True, widget=None, label=None,
+initial=None, help_text=None, *args, **kwargs):
+super(ChoiceField, self).__init__(required, widget, label, initial,
+help_text, *args, **kwargs)
+self.choices = choices
+def _get_choices(self):
+return self._choices
+def _set_choices(self, value):
+# Setting choices also sets the choices on the widget.
+# choices can be any iterable, but we call list() on it because
+# it will be consumed more than once.
+self._choices = self.widget.choices = list(value)
+choices = property(_get_choices, _set_choices)
+def clean(self, value):
+"""
+Validates that the input is in self.choices.
+"""
+value = super(ChoiceField, self).clean(value)
+if value in EMPTY_VALUES:
+value = u''
+value = smart_unicode(value)
+if value == u'':
+return value
+if not self.valid_value(value):
+raise ValidationError(self.error_messages['invalid_choice'] % {'value': value})
+return value
+def valid_value(self, value):
+"Check to see if the provided value is a valid choice"
+for k, v in self.choices:
+if type(v) in (tuple, list):
+# This is an optgroup, so look inside the group for options
+for k2, v2 in v:
+if value == smart_unicode(k2):
+return True
+else:
+if value == smart_unicode(k):
+return True
+return False
+class TypedChoiceField(ChoiceField):
+def __init__(self, *args, **kwargs):
+self.coerce = kwargs.pop('coerce', lambda val: val)
+self.empty_value = kwargs.pop('empty_value', '')
+super(TypedChoiceField, self).__init__(*args, **kwargs)
+def clean(self, value):
+"""
+Validate that the value is in self.choices and can be coerced to the
+right type.
+"""
+value = super(TypedChoiceField, self).clean(value)
+if value == self.empty_value or value in EMPTY_VALUES:
+return self.empty_value
+# Hack alert: This field is purpose-made to use with Field.to_python as
+# a coercion function so that ModelForms with choices work. However,
+# Django's Field.to_python raises django.core.exceptions.ValidationError,
+# which is a *different* exception than
+# django.forms.utils.ValidationError. So unfortunatly we need to catch
+# both.
+try:
+value = self.coerce(value)
+except (ValueError, TypeError, django.core.exceptions.ValidationError):
+raise ValidationError(self.error_messages['invalid_choice'] % {'value': value})
+return value
+class MultipleChoiceField(ChoiceField):
+hidden_widget = MultipleHiddenInput
+widget = SelectMultiple
+default_error_messages = {
+'invalid_choice': _(u'Select a valid choice. %(value)s is not one of the available choices.'),
+'invalid_list': _(u'Enter a list of values.'),
+}
+def clean(self, value):
+"""
+Validates that the input is a list or tuple.
+"""
+if self.required and not value:
+raise ValidationError(self.error_messages['required'])
+elif not self.required and not value:
+return []
+if not isinstance(value, (list, tuple)):
+raise ValidationError(self.error_messages['invalid_list'])
+new_value = [smart_unicode(val) for val in value]
+# Validate that each value in the value list is in self.choices.
+for val in new_value:
+if not self.valid_value(val):
+raise ValidationError(self.error_messages['invalid_choice'] % {'value': val})
+return new_value
+class ComboField(Field):
+"""
+A Field whose clean() method calls multiple Field clean() methods.
+"""
+def __init__(self, fields=(), *args, **kwargs):
+super(ComboField, self).__init__(*args, **kwargs)
+# Set 'required' to False on the individual fields, because the
+# required validation will be handled by ComboField, not by those
+# individual fields.
+for f in fields:
+f.required = False
+self.fields = fields
+def clean(self, value):
+"""
+Validates the given value against all of self.fields, which is a
+list of Field instances.
+"""
+super(ComboField, self).clean(value)
+for field in self.fields:
+value = field.clean(value)
+return value
+class MultiValueField(Field):
+"""
+A Field that aggregates the logic of multiple Fields.
+Its clean() method takes a "decompressed" list of values, which are then
+cleaned into a single value according to self.fields. Each value in
+this list is cleaned by the corresponding field -- the first value is
+cleaned by the first field, the second value is cleaned by the second
+field, etc. Once all fields are cleaned, the list of clean values is
+"compressed" into a single value.
+Subclasses should not have to implement clean(). Instead, they must
+implement compress(), which takes a list of valid values and returns a
+"compressed" version of those values -- a single value.
+You'll probably want to use this with MultiWidget.
+"""
+default_error_messages = {
+'invalid': _(u'Enter a list of values.'),
+}
+def __init__(self, fields=(), *args, **kwargs):
+super(MultiValueField, self).__init__(*args, **kwargs)
+# Set 'required' to False on the individual fields, because the
+# required validation will be handled by MultiValueField, not by those
+# individual fields.
+for f in fields:
+f.required = False
+self.fields = fields
+def clean(self, 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]).
+"""
+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 EMPTY_VALUES]:
+if self.required:
+raise ValidationError(self.error_messages['required'])
+else:
+return self.compress([])
+else:
+raise ValidationError(self.error_messages['invalid'])
+for i, field in enumerate(self.fields):
+try:
+field_value = value[i]
+except IndexError:
+field_value = None
+if self.required and field_value in EMPTY_VALUES:
+raise ValidationError(self.error_messages['required'])
+try:
+clean_data.append(field.clean(field_value))
+except ValidationError, e:
+# Collect all validation errors in a single list, which we'll
+# raise at the end of clean(), rather than raising a single
+# exception for the first error we encounter.
+errors.extend(e.messages)
+if errors:
+raise ValidationError(errors)
+return self.compress(clean_data)
+def compress(self, data_list):
+"""
+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.
+"""
+raise NotImplementedError('Subclasses must implement this method.')
+class FilePathField(ChoiceField):
+def __init__(self, path, match=None, recursive=False, required=True,
+widget=None, label=None, initial=None, help_text=None,
+*args, **kwargs):
+self.path, self.match, self.recursive = path, match, recursive
+super(FilePathField, self).__init__(choices=(), required=required,
+widget=widget, label=label, initial=initial, help_text=help_text,
+*args, **kwargs)
+self.choices = []
+if self.match is not None:
+self.match_re = re.compile(self.match)
+if recursive:
+for root, dirs, files in os.walk(self.path):
+for f in files:
+if self.match is None or self.match_re.search(f):
+f = os.path.join(root, f)
+self.choices.append((f, f.replace(path, "", 1)))
+else:
+try:
+for f in os.listdir(self.path):
+full_file = os.path.join(self.path, f)
+if os.path.isfile(full_file) and (self.match is None or self.match_re.search(f)):
+self.choices.append((full_file, f))
+except OSError:
+pass
+self.widget.choices = self.choices
+class SplitDateTimeField(MultiValueField):
+hidden_widget = SplitHiddenDateTimeWidget
+default_error_messages = {
+'invalid_date': _(u'Enter a valid date.'),
+'invalid_time': _(u'Enter a valid time.'),
+}
+def __init__(self, *args, **kwargs):
+errors = self.default_error_messages.copy()
+if 'error_messages' in kwargs:
+errors.update(kwargs['error_messages'])
+fields = (
+DateField(error_messages={'invalid': errors['invalid_date']}),
+TimeField(error_messages={'invalid': errors['invalid_time']}),
+)
+super(SplitDateTimeField, self).__init__(fields, *args, **kwargs)
+def compress(self, data_list):
+if data_list:
+# Raise a validation error if time or date is empty
+# (possible if SplitDateTimeField has required=False).
+if data_list[0] in EMPTY_VALUES:
+raise ValidationError(self.error_messages['invalid_date'])
+if data_list[1] in EMPTY_VALUES:
+raise ValidationError(self.error_messages['invalid_time'])
+return datetime.datetime.combine(*data_list)
+return None
+ipv4_re = re.compile(r'^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$')
+class IPAddressField(RegexField):
+default_error_messages = {
+'invalid': _(u'Enter a valid IPv4 address.'),
+}
+def __init__(self, *args, **kwargs):
+super(IPAddressField, self).__init__(ipv4_re, *args, **kwargs)
+slug_re = re.compile(r'^[-\w]+$')
+class SlugField(RegexField):
+default_error_messages = {
+'invalid': _(u"Enter a valid 'slug' consisting of letters, numbers,"
+u" underscores or hyphens."),
+}
+def __init__(self, *args, **kwargs):
+super(SlugField, self).__init__(slug_re, *args, **kwargs)