--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/app/django/forms/fields.py Tue Oct 14 16:00:59 2008 +0000
@@ -0,0 +1,892 @@
+"""
+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)