788 lines
31 KiB
Python
788 lines
31 KiB
Python
"""
|
|
Field classes.
|
|
"""
|
|
|
|
import copy
|
|
import datetime
|
|
import os
|
|
import re
|
|
import time
|
|
# 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
|
|
|
|
from django.utils.translation import ugettext_lazy as _
|
|
from django.utils.encoding import StrAndUnicode, smart_unicode, smart_str
|
|
|
|
from util import ErrorList, ValidationError
|
|
from widgets import TextInput, PasswordInput, HiddenInput, MultipleHiddenInput, FileInput, CheckboxInput, Select, NullBooleanSelect, SelectMultiple, DateTimeInput
|
|
|
|
|
|
__all__ = (
|
|
'Field', 'CharField', 'IntegerField',
|
|
'DEFAULT_DATE_INPUT_FORMATS', 'DateField',
|
|
'DEFAULT_TIME_INPUT_FORMATS', 'TimeField',
|
|
'DEFAULT_DATETIME_INPUT_FORMATS', 'DateTimeField',
|
|
'RegexField', 'EmailField', 'FileField', 'ImageField', 'URLField',
|
|
'BooleanField', 'NullBooleanField', 'ChoiceField', 'MultipleChoiceField',
|
|
'ComboField', 'MultiValueField', 'FloatField', 'DecimalField',
|
|
'SplitDateTimeField', 'IPAddressField', 'FilePathField',
|
|
)
|
|
|
|
# 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):
|
|
# 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.
|
|
if label is not None:
|
|
label = smart_unicode(label)
|
|
self.required, self.label, self.initial = required, label, initial
|
|
self.help_text = smart_unicode(help_text or '')
|
|
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'])
|
|
pieces = str(value).lstrip("-").split('.')
|
|
decimals = (len(pieces) == 2) and len(pieces[1]) or 0
|
|
digits = len(pieces[0])
|
|
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 + decimals) > 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 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):
|
|
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 UploadedFile(StrAndUnicode):
|
|
"A wrapper for files uploaded in a FileField"
|
|
def __init__(self, filename, content):
|
|
self.filename = filename
|
|
self.content = content
|
|
|
|
def __unicode__(self):
|
|
"""
|
|
The unicode representation is the filename, so that the pre-database-insertion
|
|
logic can use UploadedFile objects
|
|
"""
|
|
return self.filename
|
|
|
|
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
|
|
try:
|
|
f = UploadedFile(data['filename'], data['content'])
|
|
except TypeError:
|
|
raise ValidationError(self.error_messages['invalid'])
|
|
except KeyError:
|
|
raise ValidationError(self.error_messages['missing'])
|
|
if not f.content:
|
|
raise ValidationError(self.error_messages['empty'])
|
|
return f
|
|
|
|
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
|
|
from cStringIO import StringIO
|
|
try:
|
|
# load() is the only method that can spot a truncated JPEG,
|
|
# but it cannot be called sanely after verify()
|
|
trial_image = Image.open(StringIO(f.content))
|
|
trial_image.load()
|
|
# verify() is the only method that can spot a corrupt PNG,
|
|
# but it must be called immediately after the constructor
|
|
trial_image = Image.open(StringIO(f.content))
|
|
trial_image.verify()
|
|
except Exception: # Python Imaging Library doesn't recognize it as an image
|
|
raise ValidationError(self.error_messages['invalid_image'])
|
|
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
|
|
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):
|
|
return {True: True, False: False}.get(value, None)
|
|
|
|
class ChoiceField(Field):
|
|
widget = Select
|
|
default_error_messages = {
|
|
'invalid_choice': _(u'Select a valid choice. That choice 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
|
|
valid_values = set([smart_unicode(k) for k, v in self.choices])
|
|
if value not in valid_values:
|
|
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.
|
|
valid_values = set([smart_unicode(k) for k, v in self.choices])
|
|
for val in new_value:
|
|
if val not in valid_values:
|
|
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=Select, 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):
|
|
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)
|