--- /dev/null
+## FormEncode, a Form processor
+## Copyright (C) 2003, Ian Bicking <ianb@colorstudy.com>
+
+"""
+Validator/Converters for use with FormEncode.
+"""
+
+import cgi
+import locale
+import re
+import warnings
+from encodings import idna
+
+try: # import dnspython
+ import dns.resolver
+ import dns.exception
+except (IOError, ImportError):
+ have_dns = False
+else:
+ have_dns = True
+
+
+# These are only imported when needed
+httplib = None
+random = None
+sha1 = None
+socket = None
+urlparse = None
+
+from .api import (FancyValidator, Identity, Invalid, NoDefault, Validator,
+ deprecation_warning, is_empty)
+
+assert Identity and Invalid and NoDefault # silence unused import warnings
+
+# Dummy i18n translation function, nothing is translated here.
+# Instead this is actually done in api.message.
+# The surrounding _('string') of the strings is only for extracting
+# the strings automatically.
+# If you run pygettext with this source comment this function out temporarily.
+_ = lambda s: s
+
+
+############################################################
+## Utility methods
+############################################################
+
+# These all deal with accepting both datetime and mxDateTime modules and types
+datetime_module = None
+mxDateTime_module = None
+
+
+def import_datetime(module_type):
+ global datetime_module, mxDateTime_module
+ module_type = module_type.lower() if module_type else 'datetime'
+ if module_type == 'datetime':
+ if datetime_module is None:
+ import datetime as datetime_module
+ return datetime_module
+ elif module_type == 'mxdatetime':
+ if mxDateTime_module is None:
+ from mx import DateTime as mxDateTime_module
+ return mxDateTime_module
+ else:
+ raise ImportError('Invalid datetime module %r' % module_type)
+
+
+def datetime_now(module):
+ if module.__name__ == 'datetime':
+ return module.datetime.now()
+ else:
+ return module.now()
+
+
+def datetime_makedate(module, year, month, day):
+ if module.__name__ == 'datetime':
+ return module.date(year, month, day)
+ else:
+ try:
+ return module.DateTime(year, month, day)
+ except module.RangeError as e:
+ raise ValueError(str(e))
+
+
+def datetime_time(module):
+ if module.__name__ == 'datetime':
+ return module.time
+ else:
+ return module.Time
+
+
+def datetime_isotime(module):
+ if module.__name__ == 'datetime':
+ return module.time.isoformat
+ else:
+ return module.ISO.Time
+
+
+############################################################
+## Wrapper Validators
+############################################################
+
+class ConfirmType(FancyValidator):
+ """
+ Confirms that the input/output is of the proper type.
+
+ Uses the parameters:
+
+ subclass:
+ The class or a tuple of classes; the item must be an instance
+ of the class or a subclass.
+ type:
+ A type or tuple of types (or classes); the item must be of
+ the exact class or type. Subclasses are not allowed.
+
+ Examples::
+
+ >>> cint = ConfirmType(subclass=int)
+ >>> cint.to_python(True)
+ True
+ >>> cint.to_python('1')
+ Traceback (most recent call last):
+ ...
+ Invalid: '1' is not a subclass of <type 'int'>
+ >>> cintfloat = ConfirmType(subclass=(float, int))
+ >>> cintfloat.to_python(1.0), cintfloat.from_python(1.0)
+ (1.0, 1.0)
+ >>> cintfloat.to_python(1), cintfloat.from_python(1)
+ (1, 1)
+ >>> cintfloat.to_python(None)
+ Traceback (most recent call last):
+ ...
+ Invalid: None is not a subclass of one of the types <type 'float'>, <type 'int'>
+ >>> cint2 = ConfirmType(type=int)
+ >>> cint2(accept_python=False).from_python(True)
+ Traceback (most recent call last):
+ ...
+ Invalid: True must be of the type <type 'int'>
+ """
+
+ accept_iterator = True
+
+ subclass = None
+ type = None
+
+ messages = dict(
+ subclass=_('%(object)r is not a subclass of %(subclass)s'),
+ inSubclass=_('%(object)r is not a subclass of one of the types %(subclassList)s'),
+ inType=_('%(object)r must be one of the types %(typeList)s'),
+ type=_('%(object)r must be of the type %(type)s'))
+
+ def __init__(self, *args, **kw):
+ FancyValidator.__init__(self, *args, **kw)
+ if self.subclass:
+ if isinstance(self.subclass, list):
+ self.subclass = tuple(self.subclass)
+ elif not isinstance(self.subclass, tuple):
+ self.subclass = (self.subclass,)
+ self._validate_python = self.confirm_subclass
+ if self.type:
+ if isinstance(self.type, list):
+ self.type = tuple(self.type)
+ elif not isinstance(self.type, tuple):
+ self.type = (self.type,)
+ self._validate_python = self.confirm_type
+
+ def confirm_subclass(self, value, state):
+ if not isinstance(value, self.subclass):
+ if len(self.subclass) == 1:
+ msg = self.message('subclass', state, object=value,
+ subclass=self.subclass[0])
+ else:
+ subclass_list = ', '.join(map(str, self.subclass))
+ msg = self.message('inSubclass', state, object=value,
+ subclassList=subclass_list)
+ raise Invalid(msg, value, state)
+
+ def confirm_type(self, value, state):
+ for t in self.type:
+ if type(value) is t:
+ break
+ else:
+ if len(self.type) == 1:
+ msg = self.message('type', state, object=value,
+ type=self.type[0])
+ else:
+ msg = self.message('inType', state, object=value,
+ typeList=', '.join(map(str, self.type)))
+ raise Invalid(msg, value, state)
+ return value
+
+ def is_empty(self, value):
+ return False
+
+
+class Wrapper(FancyValidator):
+ """
+ Used to convert functions to validator/converters.
+
+ You can give a simple function for `_convert_to_python`,
+ `_convert_from_python`, `_validate_python` or `_validate_other`.
+ If that function raises an exception, the value is considered invalid.
+ Whatever value the function returns is considered the converted value.
+
+ Unlike validators, the `state` argument is not used. Functions
+ like `int` can be used here, that take a single argument.
+
+ Note that as Wrapper will generate a FancyValidator, empty
+ values (those who pass ``FancyValidator.is_empty)`` will return ``None``.
+ To override this behavior you can use ``Wrapper(empty_value=callable)``.
+ For example passing ``Wrapper(empty_value=lambda val: val)`` will return
+ the value itself when is considered empty.
+
+ Examples::
+
+ >>> def downcase(v):
+ ... return v.lower()
+ >>> wrap = Wrapper(convert_to_python=downcase)
+ >>> wrap.to_python('This')
+ 'this'
+ >>> wrap.from_python('This')
+ 'This'
+ >>> wrap.to_python('') is None
+ True
+ >>> wrap2 = Wrapper(
+ ... convert_from_python=downcase, empty_value=lambda value: value)
+ >>> wrap2.from_python('This')
+ 'this'
+ >>> wrap2.to_python('')
+ ''
+ >>> wrap2.from_python(1)
+ Traceback (most recent call last):
+ ...
+ Invalid: 'int' object has no attribute 'lower'
+ >>> wrap3 = Wrapper(validate_python=int)
+ >>> wrap3.to_python('1')
+ '1'
+ >>> wrap3.to_python('a') # doctest: +ELLIPSIS
+ Traceback (most recent call last):
+ ...
+ Invalid: invalid literal for int()...
+ """
+
+ func_convert_to_python = None
+ func_convert_from_python = None
+ func_validate_python = None
+ func_validate_other = None
+
+ _deprecated_methods = (
+ ('func_to_python', 'func_convert_to_python'),
+ ('func_from_python', 'func_convert_from_python'))
+
+ def __init__(self, *args, **kw):
+ # allow old method names as parameters
+ if 'to_python' in kw and 'convert_to_python' not in kw:
+ kw['convert_to_python'] = kw.pop('to_python')
+ if 'from_python' in kw and 'convert_from_python' not in kw:
+ kw['convert_from_python'] = kw.pop('from_python')
+ for n in ('convert_to_python', 'convert_from_python',
+ 'validate_python', 'validate_other'):
+ if n in kw:
+ kw['func_%s' % n] = kw.pop(n)
+ FancyValidator.__init__(self, *args, **kw)
+ self._convert_to_python = self.wrap(self.func_convert_to_python)
+ self._convert_from_python = self.wrap(self.func_convert_from_python)
+ self._validate_python = self.wrap(self.func_validate_python)
+ self._validate_other = self.wrap(self.func_validate_other)
+
+ def wrap(self, func):
+ if not func:
+ return None
+
+ def result(value, state, func=func):
+ try:
+ return func(value)
+ except Exception as e:
+ raise Invalid(str(e), value, state)
+
+ return result
+
+
+class Constant(FancyValidator):
+ """
+ This converter converts everything to the same thing.
+
+ I.e., you pass in the constant value when initializing, then all
+ values get converted to that constant value.
+
+ This is only really useful for funny situations, like::
+
+ # Any evaluates sub validators in reverse order for to_python
+ fromEmailValidator = Any(
+ Constant('unknown@localhost'),
+ Email())
+
+ In this case, the if the email is not valid
+ ``'unknown@localhost'`` will be used instead. Of course, you
+ could use ``if_invalid`` instead.
+
+ Examples::
+
+ >>> Constant('X').to_python('y')
+ 'X'
+ """
+
+ __unpackargs__ = ('value',)
+
+ def _convert_to_python(self, value, state):
+ return self.value
+
+ _convert_from_python = _convert_to_python
+
+
+############################################################
+## Normal validators
+############################################################
+
+class MaxLength(FancyValidator):
+ """
+ Invalid if the value is longer than `maxLength`. Uses len(),
+ so it can work for strings, lists, or anything with length.
+
+ Examples::
+
+ >>> max5 = MaxLength(5)
+ >>> max5.to_python('12345')
+ '12345'
+ >>> max5.from_python('12345')
+ '12345'
+ >>> max5.to_python('123456')
+ Traceback (most recent call last):
+ ...
+ Invalid: Enter a value less than 5 characters long
+ >>> max5(accept_python=False).from_python('123456')
+ Traceback (most recent call last):
+ ...
+ Invalid: Enter a value less than 5 characters long
+ >>> max5.to_python([1, 2, 3])
+ [1, 2, 3]
+ >>> max5.to_python([1, 2, 3, 4, 5, 6])
+ Traceback (most recent call last):
+ ...
+ Invalid: Enter a value less than 5 characters long
+ >>> max5.to_python(5)
+ Traceback (most recent call last):
+ ...
+ Invalid: Invalid value (value with length expected)
+ """
+
+ __unpackargs__ = ('maxLength',)
+
+ messages = dict(
+ tooLong=_('Enter a value less than %(maxLength)i characters long'),
+ invalid=_('Invalid value (value with length expected)'))
+
+ def _validate_python(self, value, state):
+ try:
+ if value and len(value) > self.maxLength:
+ raise Invalid(
+ self.message('tooLong', state,
+ maxLength=self.maxLength), value, state)
+ else:
+ return None
+ except TypeError:
+ raise Invalid(
+ self.message('invalid', state), value, state)
+
+
+class MinLength(FancyValidator):
+ """
+ Invalid if the value is shorter than `minlength`. Uses len(), so
+ it can work for strings, lists, or anything with length. Note
+ that you **must** use ``not_empty=True`` if you don't want to
+ accept empty values -- empty values are not tested for length.
+
+ Examples::
+
+ >>> min5 = MinLength(5)
+ >>> min5.to_python('12345')
+ '12345'
+ >>> min5.from_python('12345')
+ '12345'
+ >>> min5.to_python('1234')
+ Traceback (most recent call last):
+ ...
+ Invalid: Enter a value at least 5 characters long
+ >>> min5(accept_python=False).from_python('1234')
+ Traceback (most recent call last):
+ ...
+ Invalid: Enter a value at least 5 characters long
+ >>> min5.to_python([1, 2, 3, 4, 5])
+ [1, 2, 3, 4, 5]
+ >>> min5.to_python([1, 2, 3])
+ Traceback (most recent call last):
+ ...
+ Invalid: Enter a value at least 5 characters long
+ >>> min5.to_python(5)
+ Traceback (most recent call last):
+ ...
+ Invalid: Invalid value (value with length expected)
+
+ """
+
+ __unpackargs__ = ('minLength',)
+
+ messages = dict(
+ tooShort=_('Enter a value at least %(minLength)i characters long'),
+ invalid=_('Invalid value (value with length expected)'))
+
+ def _validate_python(self, value, state):
+ try:
+ if len(value) < self.minLength:
+ raise Invalid(
+ self.message('tooShort', state,
+ minLength=self.minLength), value, state)
+ except TypeError:
+ raise Invalid(
+ self.message('invalid', state), value, state)
+
+
+class NotEmpty(FancyValidator):
+ """
+ Invalid if value is empty (empty string, empty list, etc).
+
+ Generally for objects that Python considers false, except zero
+ which is not considered invalid.
+
+ Examples::
+
+ >>> ne = NotEmpty(messages=dict(empty='enter something'))
+ >>> ne.to_python('')
+ Traceback (most recent call last):
+ ...
+ Invalid: enter something
+ >>> ne.to_python(0)
+ 0
+ """
+ not_empty = True
+
+ messages = dict(
+ empty=_('Please enter a value'))
+
+ def _validate_python(self, value, state):
+ if value == 0:
+ # This isn't "empty" for this definition.
+ return value
+ if not value:
+ raise Invalid(self.message('empty', state), value, state)
+
+
+class Empty(FancyValidator):
+ """
+ Invalid unless the value is empty. Use cleverly, if at all.
+
+ Examples::
+
+ >>> Empty.to_python(0)
+ Traceback (most recent call last):
+ ...
+ Invalid: You cannot enter a value here
+ """
+
+ messages = dict(
+ notEmpty=_('You cannot enter a value here'))
+
+ def _validate_python(self, value, state):
+ if value or value == 0:
+ raise Invalid(self.message('notEmpty', state), value, state)
+
+
+class Regex(FancyValidator):
+ """
+ Invalid if the value doesn't match the regular expression `regex`.
+
+ The regular expression can be a compiled re object, or a string
+ which will be compiled for you.
+
+ Use strip=True if you want to strip the value before validation,
+ and as a form of conversion (often useful).
+
+ Examples::
+
+ >>> cap = Regex(r'^[A-Z]+$')
+ >>> cap.to_python('ABC')
+ 'ABC'
+
+ Note that ``.from_python()`` calls (in general) do not validate
+ the input::
+
+ >>> cap.from_python('abc')
+ 'abc'
+ >>> cap(accept_python=False).from_python('abc')
+ Traceback (most recent call last):
+ ...
+ Invalid: The input is not valid
+ >>> cap.to_python(1)
+ Traceback (most recent call last):
+ ...
+ Invalid: The input must be a string (not a <type 'int'>: 1)
+ >>> Regex(r'^[A-Z]+$', strip=True).to_python(' ABC ')
+ 'ABC'
+ >>> Regex(r'this', regexOps=('I',)).to_python('THIS')
+ 'THIS'
+ """
+
+ regexOps = ()
+ strip = False
+ regex = None
+
+ __unpackargs__ = ('regex',)
+
+ messages = dict(
+ invalid=_('The input is not valid'))
+
+ def __init__(self, *args, **kw):
+ FancyValidator.__init__(self, *args, **kw)
+ if isinstance(self.regex, str):
+ ops = 0
+ assert not isinstance(self.regexOps, str), (
+ "regexOps should be a list of options from the re module "
+ "(names, or actual values)")
+ for op in self.regexOps:
+ if isinstance(op, str):
+ ops |= getattr(re, op)
+ else:
+ ops |= op
+ self.regex = re.compile(self.regex, ops)
+
+ def _validate_python(self, value, state):
+ self.assert_string(value, state)
+ if self.strip and isinstance(value, str):
+ value = value.strip()
+ if not self.regex.search(value):
+ raise Invalid(self.message('invalid', state), value, state)
+
+ def _convert_to_python(self, value, state):
+ if self.strip and isinstance(value, str):
+ return value.strip()
+ return value
+
+
+class PlainText(Regex):
+ """
+ Test that the field contains only letters, numbers, underscore,
+ and the hyphen. Subclasses Regex.
+
+ Examples::
+
+ >>> PlainText.to_python('_this9_')
+ '_this9_'
+ >>> PlainText.from_python(' this ')
+ ' this '
+ >>> PlainText(accept_python=False).from_python(' this ')
+ Traceback (most recent call last):
+ ...
+ Invalid: Enter only letters, numbers, or _ (underscore)
+ >>> PlainText(strip=True).to_python(' this ')
+ 'this'
+ >>> PlainText(strip=True).from_python(' this ')
+ 'this'
+ """
+
+ regex = r"^[a-zA-Z_\-0-9]*$"
+
+ messages = dict(
+ invalid=_('Enter only letters, numbers, or _ (underscore)'))
+
+
+class OneOf(FancyValidator):
+ """
+ Tests that the value is one of the members of a given list.
+
+ If ``testValueList=True``, then if the input value is a list or
+ tuple, all the members of the sequence will be checked (i.e., the
+ input must be a subset of the allowed values).
+
+ Use ``hideList=True`` to keep the list of valid values out of the
+ error message in exceptions.
+
+ Examples::
+
+ >>> oneof = OneOf([1, 2, 3])
+ >>> oneof.to_python(1)
+ 1
+ >>> oneof.to_python(4)
+ Traceback (most recent call last):
+ ...
+ Invalid: Value must be one of: 1; 2; 3 (not 4)
+ >>> oneof(testValueList=True).to_python([2, 3, [1, 2, 3]])
+ [2, 3, [1, 2, 3]]
+ >>> oneof.to_python([2, 3, [1, 2, 3]])
+ Traceback (most recent call last):
+ ...
+ Invalid: Value must be one of: 1; 2; 3 (not [2, 3, [1, 2, 3]])
+ """
+
+ list = None
+ testValueList = False
+ hideList = False
+
+ __unpackargs__ = ('list',)
+
+ messages = dict(
+ invalid=_('Invalid value'),
+ notIn=_('Value must be one of: %(items)s (not %(value)r)'))
+
+ def _validate_python(self, value, state):
+ if self.testValueList and isinstance(value, (list, tuple)):
+ for v in value:
+ self._validate_python(v, state)
+ else:
+ if not value in self.list:
+ if self.hideList:
+ raise Invalid(self.message('invalid', state), value, state)
+ else:
+ try:
+ items = '; '.join(map(str, self.list))
+ except UnicodeError:
+ items = '; '.join(map(str, self.list))
+ raise Invalid(
+ self.message('notIn', state,
+ items=items, value=value), value, state)
+
+ @property
+ def accept_iterator(self):
+ return self.testValueList
+
+
+class DictConverter(FancyValidator):
+ """
+ Converts values based on a dictionary which has values as keys for
+ the resultant values.
+
+ If ``allowNull`` is passed, it will not balk if a false value
+ (e.g., '' or None) is given (it will return None in these cases).
+
+ to_python takes keys and gives values, from_python takes values and
+ gives keys.
+
+ If you give hideDict=True, then the contents of the dictionary
+ will not show up in error messages.
+
+ Examples::
+
+ >>> dc = DictConverter({1: 'one', 2: 'two'})
+ >>> dc.to_python(1)
+ 'one'
+ >>> dc.from_python('one')
+ 1
+ >>> dc.to_python(3)
+ Traceback (most recent call last):
+ ....
+ Invalid: Enter a value from: 1; 2
+ >>> dc2 = dc(hideDict=True)
+ >>> dc2.hideDict
+ True
+ >>> dc2.dict
+ {1: 'one', 2: 'two'}
+ >>> dc2.to_python(3)
+ Traceback (most recent call last):
+ ....
+ Invalid: Choose something
+ >>> dc.from_python('three')
+ Traceback (most recent call last):
+ ....
+ Invalid: Nothing in my dictionary goes by the value 'three'. Choose one of: 'one'; 'two'
+ """
+
+ messages = dict(
+ keyNotFound=_('Choose something'),
+ chooseKey=_('Enter a value from: %(items)s'),
+ valueNotFound=_('That value is not known'),
+ chooseValue=_('Nothing in my dictionary goes by the value %(value)s.'
+ ' Choose one of: %(items)s'))
+
+ dict = None
+ hideDict = False
+
+ __unpackargs__ = ('dict',)
+
+ def _convert_to_python(self, value, state):
+ try:
+ return self.dict[value]
+ except KeyError:
+ if self.hideDict:
+ raise Invalid(self.message('keyNotFound', state), value, state)
+ else:
+ items = sorted(self.dict)
+ items = '; '.join(map(repr, items))
+ raise Invalid(self.message('chooseKey',
+ state, items=items), value, state)
+
+ def _convert_from_python(self, value, state):
+ for k, v in self.dict.items():
+ if value == v:
+ return k
+ if self.hideDict:
+ raise Invalid(self.message('valueNotFound', state), value, state)
+ else:
+ items = '; '.join(map(repr, iter(self.dict.values())))
+ raise Invalid(
+ self.message('chooseValue', state,
+ value=repr(value), items=items), value, state)
+
+
+class IndexListConverter(FancyValidator):
+ """
+ Converts a index (which may be a string like '2') to the value in
+ the given list.
+
+ Examples::
+
+ >>> index = IndexListConverter(['zero', 'one', 'two'])
+ >>> index.to_python(0)
+ 'zero'
+ >>> index.from_python('zero')
+ 0
+ >>> index.to_python('1')
+ 'one'
+ >>> index.to_python(5)
+ Traceback (most recent call last):
+ Invalid: Index out of range
+ >>> index(not_empty=True).to_python(None)
+ Traceback (most recent call last):
+ Invalid: Please enter a value
+ >>> index.from_python('five')
+ Traceback (most recent call last):
+ Invalid: Item 'five' was not found in the list
+ """
+
+ list = None
+
+ __unpackargs__ = ('list',)
+
+ messages = dict(
+ integer=_('Must be an integer index'),
+ outOfRange=_('Index out of range'),
+ notFound=_('Item %(value)s was not found in the list'))
+
+ def _convert_to_python(self, value, state):
+ try:
+ value = int(value)
+ except (ValueError, TypeError):
+ raise Invalid(self.message('integer', state), value, state)
+ try:
+ return self.list[value]
+ except IndexError:
+ raise Invalid(self.message('outOfRange', state), value, state)
+
+ def _convert_from_python(self, value, state):
+ for i, v in enumerate(self.list):
+ if v == value:
+ return i
+ raise Invalid(
+ self.message('notFound', state, value=repr(value)), value, state)
+
+
+class DateValidator(FancyValidator):
+ """
+ Validates that a date is within the given range. Be sure to call
+ DateConverter first if you aren't expecting mxDateTime input.
+
+ ``earliest_date`` and ``latest_date`` may be functions; if so,
+ they will be called each time before validating.
+
+ ``after_now`` means a time after the current timestamp; note that
+ just a few milliseconds before now is invalid! ``today_or_after``
+ is more permissive, and ignores hours and minutes.
+
+ Examples::
+
+ >>> from datetime import datetime, timedelta
+ >>> d = DateValidator(earliest_date=datetime(2003, 1, 1))
+ >>> d.to_python(datetime(2004, 1, 1))
+ datetime.datetime(2004, 1, 1, 0, 0)
+ >>> d.to_python(datetime(2002, 1, 1))
+ Traceback (most recent call last):
+ ...
+ Invalid: Date must be after Wednesday, 01 January 2003
+ >>> d.to_python(datetime(2003, 1, 1))
+ datetime.datetime(2003, 1, 1, 0, 0)
+ >>> d = DateValidator(after_now=True)
+ >>> now = datetime.now()
+ >>> d.to_python(now+timedelta(seconds=5)) == now+timedelta(seconds=5)
+ True
+ >>> d.to_python(now-timedelta(days=1))
+ Traceback (most recent call last):
+ ...
+ Invalid: The date must be sometime in the future
+ >>> d.to_python(now+timedelta(days=1)) > now
+ True
+ >>> d = DateValidator(today_or_after=True)
+ >>> d.to_python(now) == now
+ True
+
+ """
+
+ earliest_date = None
+ latest_date = None
+ after_now = False
+ # Like after_now, but just after this morning:
+ today_or_after = False
+ # Use None or 'datetime' for the datetime module in the standard lib,
+ # or 'mxDateTime' to force the mxDateTime module
+ datetime_module = None
+
+ messages = dict(
+ after=_('Date must be after %(date)s'),
+ before=_('Date must be before %(date)s'),
+ # Double %'s, because this will be substituted twice:
+ date_format=_('%%A, %%d %%B %%Y'),
+ future=_('The date must be sometime in the future'))
+
+ def _validate_python(self, value, state):
+ date_format = self.message('date_format', state)
+ if (str is not str # Python 2
+ and isinstance(date_format, str)):
+ # strftime uses the locale encoding, not Unicode
+ encoding = locale.getlocale(locale.LC_TIME)[1] or 'utf-8'
+ date_format = date_format.encode(encoding)
+ else:
+ encoding = None
+ if self.earliest_date:
+ if callable(self.earliest_date):
+ earliest_date = self.earliest_date()
+ else:
+ earliest_date = self.earliest_date
+ if value < earliest_date:
+ date_formatted = earliest_date.strftime(date_format)
+ if encoding:
+ date_formatted = date_formatted.decode(encoding)
+ raise Invalid(
+ self.message('after', state, date=date_formatted),
+ value, state)
+ if self.latest_date:
+ if callable(self.latest_date):
+ latest_date = self.latest_date()
+ else:
+ latest_date = self.latest_date
+ if value > latest_date:
+ date_formatted = latest_date.strftime(date_format)
+ if encoding:
+ date_formatted = date_formatted.decode(encoding)
+ raise Invalid(
+ self.message('before', state, date=date_formatted),
+ value, state)
+ if self.after_now:
+ dt_mod = import_datetime(self.datetime_module)
+ now = datetime_now(dt_mod)
+ if value < now:
+ date_formatted = now.strftime(date_format)
+ if encoding:
+ date_formatted = date_formatted.decode(encoding)
+ raise Invalid(
+ self.message('future', state, date=date_formatted),
+ value, state)
+ if self.today_or_after:
+ dt_mod = import_datetime(self.datetime_module)
+ now = datetime_now(dt_mod)
+ today = datetime_makedate(dt_mod,
+ now.year, now.month, now.day)
+ value_as_date = datetime_makedate(
+ dt_mod, value.year, value.month, value.day)
+ if value_as_date < today:
+ date_formatted = now.strftime(date_format)
+ if encoding:
+ date_formatted = date_formatted.decode(encoding)
+ raise Invalid(
+ self.message('future', state, date=date_formatted),
+ value, state)
+
+
+class Bool(FancyValidator):
+ """
+ Always Valid, returns True or False based on the value and the
+ existance of the value.
+
+ If you want to convert strings like ``'true'`` to booleans, then
+ use ``StringBool``.
+
+ Examples::
+
+ >>> Bool.to_python(0)
+ False
+ >>> Bool.to_python(1)
+ True
+ >>> Bool.to_python('')
+ False
+ >>> Bool.to_python(None)
+ False
+ """
+
+ if_missing = False
+
+ def _convert_to_python(self, value, state):
+ return bool(value)
+
+ _convert_from_python = _convert_to_python
+
+ def empty_value(self, value):
+ return False
+
+
+class RangeValidator(FancyValidator):
+ """This is an abstract base class for Int and Number.
+
+ It verifies that a value is within range. It accepts min and max
+ values in the constructor.
+
+ (Since this is an abstract base class, the tests are in Int and Number.)
+
+ """
+
+ messages = dict(
+ tooLow=_('Please enter a number that is %(min)s or greater'),
+ tooHigh=_('Please enter a number that is %(max)s or smaller'))
+
+ min = None
+ max = None
+
+ def _validate_python(self, value, state):
+ if self.min is not None:
+ if value < self.min:
+ msg = self.message('tooLow', state, min=self.min)
+ raise Invalid(msg, value, state)
+ if self.max is not None:
+ if value > self.max:
+ msg = self.message('tooHigh', state, max=self.max)
+ raise Invalid(msg, value, state)
+
+
+class Int(RangeValidator):
+ """Convert a value to an integer.
+
+ Example::
+
+ >>> Int.to_python('10')
+ 10
+ >>> Int.to_python('ten')
+ Traceback (most recent call last):
+ ...
+ Invalid: Please enter an integer value
+ >>> Int(min=5).to_python('6')
+ 6
+ >>> Int(max=10).to_python('11')
+ Traceback (most recent call last):
+ ...
+ Invalid: Please enter a number that is 10 or smaller
+
+ """
+
+ messages = dict(
+ integer=_('Please enter an integer value'))
+
+ def _convert_to_python(self, value, state):
+ try:
+ return int(value)
+ except (ValueError, TypeError):
+ raise Invalid(self.message('integer', state), value, state)
+
+ _convert_from_python = _convert_to_python
+
+
+class Number(RangeValidator):
+ """Convert a value to a float or integer.
+
+ Tries to convert it to an integer if no information is lost.
+
+ Example::
+
+ >>> Number.to_python('10')
+ 10
+ >>> Number.to_python('10.5')
+ 10.5
+ >>> Number.to_python('ten')
+ Traceback (most recent call last):
+ ...
+ Invalid: Please enter a number
+ >>> Number.to_python([1.2])
+ Traceback (most recent call last):
+ ...
+ Invalid: Please enter a number
+ >>> Number(min=5).to_python('6.5')
+ 6.5
+ >>> Number(max=10.5).to_python('11.5')
+ Traceback (most recent call last):
+ ...
+ Invalid: Please enter a number that is 10.5 or smaller
+
+ """
+
+ messages = dict(
+ number=_('Please enter a number'))
+
+ def _convert_to_python(self, value, state):
+ try:
+ value = float(value)
+ try:
+ int_value = int(value)
+ except OverflowError:
+ int_value = None
+ if value == int_value:
+ return int_value
+ return value
+ except (ValueError, TypeError):
+ raise Invalid(self.message('number', state), value, state)
+
+
+class ByteString(FancyValidator):
+ """Convert to byte string, treating empty things as the empty string.
+
+ Under Python 2.x you can also use the alias `String` for this validator.
+
+ Also takes a `max` and `min` argument, and the string length must fall
+ in that range.
+
+ Also you may give an `encoding` argument, which will encode any unicode
+ that is found. Lists and tuples are joined with `list_joiner`
+ (default ``', '``) in ``from_python``.
+
+ ::
+
+ >>> ByteString(min=2).to_python('a')
+ Traceback (most recent call last):
+ ...
+ Invalid: Enter a value 2 characters long or more
+ >>> ByteString(max=10).to_python('xxxxxxxxxxx')
+ Traceback (most recent call last):
+ ...
+ Invalid: Enter a value not more than 10 characters long
+ >>> ByteString().from_python(None)
+ ''
+ >>> ByteString().from_python([])
+ ''
+ >>> ByteString().to_python(None)
+ ''
+ >>> ByteString(min=3).to_python(None)
+ Traceback (most recent call last):
+ ...
+ Invalid: Please enter a value
+ >>> ByteString(min=1).to_python('')
+ Traceback (most recent call last):
+ ...
+ Invalid: Please enter a value
+
+ """
+
+ min = None
+ max = None
+ not_empty = None
+ encoding = None
+ list_joiner = ', '
+
+ messages = dict(
+ tooLong=_('Enter a value not more than %(max)i characters long'),
+ tooShort=_('Enter a value %(min)i characters long or more'))
+
+ def __initargs__(self, new_attrs):
+ if self.not_empty is None and self.min:
+ self.not_empty = True
+
+ def _convert_to_python(self, value, state):
+ if value is None:
+ value = ''
+ elif not isinstance(value, str):
+ try:
+ value = bytes(value)
+ except UnicodeEncodeError:
+ value = str(value)
+ if self.encoding is not None and isinstance(value, str):
+ value = value.encode(self.encoding)
+ return value
+
+ def _convert_from_python(self, value, state):
+ if value is None:
+ value = ''
+ elif not isinstance(value, str):
+ if isinstance(value, (list, tuple)):
+ value = self.list_joiner.join(
+ self._convert_from_python(v, state) for v in value)
+ try:
+ value = str(value)
+ except UnicodeEncodeError:
+ value = str(value)
+ if self.encoding is not None and isinstance(value, str):
+ value = value.encode(self.encoding)
+ if self.strip:
+ value = value.strip()
+ return value
+
+ def _validate_other(self, value, state):
+ if self.max is None and self.min is None:
+ return
+ if value is None:
+ value = ''
+ elif not isinstance(value, str):
+ try:
+ value = str(value)
+ except UnicodeEncodeError:
+ value = str(value)
+ if self.max is not None and len(value) > self.max:
+ raise Invalid(
+ self.message('tooLong', state, max=self.max), value, state)
+ if self.min is not None and len(value) < self.min:
+ raise Invalid(
+ self.message('tooShort', state, min=self.min), value, state)
+
+ def empty_value(self, value):
+ return ''
+
+
+class UnicodeString(ByteString):
+ """Convert things to unicode string.
+
+ This is implemented as a specialization of the ByteString class.
+
+ Under Python 3.x you can also use the alias `String` for this validator.
+
+ In addition to the String arguments, an encoding argument is also
+ accepted. By default the encoding will be utf-8. You can overwrite
+ this using the encoding parameter. You can also set inputEncoding
+ and outputEncoding differently. An inputEncoding of None means
+ "do not decode", an outputEncoding of None means "do not encode".
+
+ All converted strings are returned as Unicode strings.
+
+ ::
+
+ >>> UnicodeString().to_python(None)
+ u''
+ >>> UnicodeString().to_python([])
+ u''
+ >>> UnicodeString(encoding='utf-7').to_python('Ni Ni Ni')
+ u'Ni Ni Ni'
+
+ """
+ encoding = 'utf-8'
+ inputEncoding = NoDefault
+ outputEncoding = NoDefault
+ messages = dict(
+ badEncoding=_('Invalid data or incorrect encoding'))
+
+ def __init__(self, **kw):
+ ByteString.__init__(self, **kw)
+ if self.inputEncoding is NoDefault:
+ self.inputEncoding = self.encoding
+ if self.outputEncoding is NoDefault:
+ self.outputEncoding = self.encoding
+
+ def _convert_to_python(self, value, state):
+ if not value:
+ return ''
+ if isinstance(value, str):
+ return value
+ if not isinstance(value, str):
+ if hasattr(value, '__unicode__'):
+ value = str(value)
+ return value
+ if not (str is str # Python 3
+ and isinstance(value, bytes) and self.inputEncoding):
+ value = str(value)
+ if self.inputEncoding and not isinstance(value, str):
+ try:
+ value = str(value, self.inputEncoding)
+ except UnicodeDecodeError:
+ raise Invalid(self.message('badEncoding', state), value, state)
+ except TypeError:
+ raise Invalid(
+ self.message('badType', state,
+ type=type(value), value=value), value, state)
+ return value
+
+ def _convert_from_python(self, value, state):
+ if not isinstance(value, str):
+ if hasattr(value, '__unicode__'):
+ value = str(value)
+ else:
+ value = str(value)
+ if self.outputEncoding and isinstance(value, str):
+ value = value.encode(self.outputEncoding)
+ return value
+
+ def empty_value(self, value):
+ return ''
+
+
+# Provide proper alias for native strings
+
+String = UnicodeString if str is str else ByteString
+
+
+class Set(FancyValidator):
+ """
+ This is for when you think you may return multiple values for a
+ certain field.
+
+ This way the result will always be a list, even if there's only
+ one result. It's equivalent to ForEach(convert_to_list=True).
+
+ If you give ``use_set=True``, then it will return an actual
+ ``set`` object.
+
+ ::
+
+ >>> Set.to_python(None)
+ []
+ >>> Set.to_python('this')
+ ['this']
+ >>> Set.to_python(('this', 'that'))
+ ['this', 'that']
+ >>> s = Set(use_set=True)
+ >>> s.to_python(None)
+ set([])
+ >>> s.to_python('this')
+ set(['this'])
+ >>> s.to_python(('this',))
+ set(['this'])
+ """
+
+ use_set = False
+
+ if_missing = ()
+ accept_iterator = True
+
+ def _convert_to_python(self, value, state):
+ if self.use_set:
+ if isinstance(value, set):
+ return value
+ elif isinstance(value, (list, tuple)):
+ return set(value)
+ elif value is None:
+ return set()
+ else:
+ return set([value])
+ else:
+ if isinstance(value, list):
+ return value
+ elif isinstance(value, set):
+ return list(value)
+ elif isinstance(value, tuple):
+ return list(value)
+ elif value is None:
+ return []
+ else:
+ return [value]
+
+ def empty_value(self, value):
+ if self.use_set:
+ return set()
+ else:
+ return []
+
+
+class Email(FancyValidator):
+ r"""
+ Validate an email address.
+
+ If you pass ``resolve_domain=True``, then it will try to resolve
+ the domain name to make sure it's valid. This takes longer, of
+ course. You must have the `dnspython <http://www.dnspython.org/>`__ modules
+ installed to look up DNS (MX and A) records.
+
+ ::
+
+ >>> e = Email()
+ >>> e.to_python(' test@foo.com ')
+ 'test@foo.com'
+ >>> e.to_python('test')
+ Traceback (most recent call last):
+ ...
+ Invalid: An email address must contain a single @
+ >>> e.to_python('test@foobar')
+ Traceback (most recent call last):
+ ...
+ Invalid: The domain portion of the email address is invalid (the portion after the @: foobar)
+ >>> e.to_python('test@foobar.com.5')
+ Traceback (most recent call last):
+ ...
+ Invalid: The domain portion of the email address is invalid (the portion after the @: foobar.com.5)
+ >>> e.to_python('test@foo..bar.com')
+ Traceback (most recent call last):
+ ...
+ Invalid: The domain portion of the email address is invalid (the portion after the @: foo..bar.com)
+ >>> e.to_python('test@.foo.bar.com')
+ Traceback (most recent call last):
+ ...
+ Invalid: The domain portion of the email address is invalid (the portion after the @: .foo.bar.com)
+ >>> e.to_python('nobody@xn--m7r7ml7t24h.com')
+ 'nobody@xn--m7r7ml7t24h.com'
+ >>> e.to_python('o*reilly@test.com')
+ 'o*reilly@test.com'
+ >>> e = Email(resolve_domain=True)
+ >>> e.resolve_domain
+ True
+ >>> e.to_python('doesnotexist@colorstudy.com')
+ 'doesnotexist@colorstudy.com'
+ >>> e.to_python('test@nyu.edu')
+ 'test@nyu.edu'
+ >>> # NOTE: If you do not have dnspython installed this example won't work:
+ >>> e.to_python('test@thisdomaindoesnotexistithinkforsure.com')
+ Traceback (most recent call last):
+ ...
+ Invalid: The domain of the email address does not exist (the portion after the @: thisdomaindoesnotexistithinkforsure.com)
+ >>> e.to_python('test@google.com')
+ u'test@google.com'
+ >>> e = Email(not_empty=False)
+ >>> e.to_python('')
+
+ """
+
+ resolve_domain = False
+ resolve_timeout = 10 # timeout in seconds when resolving domains
+
+ usernameRE = re.compile(r"^[\w!#$%&'*+\-/=?^`{|}~.]+$")
+ domainRE = re.compile(r'''
+ ^(?:[a-z0-9][a-z0-9\-]{,62}\.)+ # subdomain
+ (?:[a-z]{2,63}|xn--[a-z0-9\-]{2,59})$ # top level domain
+ ''', re.I | re.VERBOSE)
+
+ messages = dict(
+ empty=_('Please enter an email address'),
+ noAt=_('An email address must contain a single @'),
+ badUsername=_('The username portion of the email address is invalid'
+ ' (the portion before the @: %(username)s)'),
+ socketError=_('An error occured when trying to connect to the server:'
+ ' %(error)s'),
+ badDomain=_('The domain portion of the email address is invalid'
+ ' (the portion after the @: %(domain)s)'),
+ domainDoesNotExist=_('The domain of the email address does not exist'
+ ' (the portion after the @: %(domain)s)'))
+
+ def __init__(self, *args, **kw):
+ FancyValidator.__init__(self, *args, **kw)
+ if self.resolve_domain:
+ if not have_dns:
+ warnings.warn(
+ "dnspython <http://www.dnspython.org/> is not installed on"
+ " your system (or the dns.resolver package cannot be found)."
+ " I cannot resolve domain names in addresses")
+ raise ImportError("no module named dns.resolver")
+
+ def _validate_python(self, value, state):
+ if not value:
+ raise Invalid(self.message('empty', state), value, state)
+ value = value.strip()
+ splitted = value.split('@', 1)
+ try:
+ username, domain = splitted
+ except ValueError:
+ raise Invalid(self.message('noAt', state), value, state)
+ if not self.usernameRE.search(username):
+ raise Invalid(
+ self.message('badUsername', state, username=username),
+ value, state)
+ try:
+ idna_domain = [idna.ToASCII(p) for p in domain.split('.')]
+ if str is str: # Python 3
+ idna_domain = [p.decode('ascii') for p in idna_domain]
+ idna_domain = '.'.join(idna_domain)
+ except UnicodeError:
+ # UnicodeError: label empty or too long
+ # This exception might happen if we have an invalid domain name part
+ # (for example test@.foo.bar.com)
+ raise Invalid(
+ self.message('badDomain', state, domain=domain),
+ value, state)
+ if not self.domainRE.search(idna_domain):
+ raise Invalid(
+ self.message('badDomain', state, domain=domain),
+ value, state)
+ if self.resolve_domain:
+ assert have_dns, "dnspython should be available"
+ global socket
+ if socket is None:
+ import socket
+ try:
+ try:
+ dns.resolver.query(domain, 'MX')
+ except (dns.resolver.NXDOMAIN, dns.resolver.NoAnswer) as e:
+ try:
+ dns.resolver.query(domain, 'A')
+ except (dns.resolver.NXDOMAIN, dns.resolver.NoAnswer) as e:
+ raise Invalid(
+ self.message('domainDoesNotExist',
+ state, domain=domain), value, state)
+ except (socket.error, dns.exception.DNSException) as e:
+ raise Invalid(
+ self.message('socketError', state, error=e), value, state)
+
+ def _convert_to_python(self, value, state):
+ return value.strip()
+
+
+class URL(FancyValidator):
+ """
+ Validate a URL, either http://... or https://. If check_exists
+ is true, then we'll actually make a request for the page.
+
+ If add_http is true, then if no scheme is present we'll add
+ http://
+
+ ::
+
+ >>> u = URL(add_http=True)
+ >>> u.to_python('foo.com')
+ 'http://foo.com'
+ >>> u.to_python('http://hahaha.ha/bar.html')
+ 'http://hahaha.ha/bar.html'
+ >>> u.to_python('http://xn--m7r7ml7t24h.com')
+ 'http://xn--m7r7ml7t24h.com'
+ >>> u.to_python('http://xn--c1aay4a.xn--p1ai')
+ 'http://xn--c1aay4a.xn--p1ai'
+ >>> u.to_python('http://foo.com/test?bar=baz&fleem=morx')
+ 'http://foo.com/test?bar=baz&fleem=morx'
+ >>> u.to_python('http://foo.com/login?came_from=http%3A%2F%2Ffoo.com%2Ftest')
+ 'http://foo.com/login?came_from=http%3A%2F%2Ffoo.com%2Ftest'
+ >>> u.to_python('http://foo.com:8000/test.html')
+ 'http://foo.com:8000/test.html'
+ >>> u.to_python('http://foo.com/something\\nelse')
+ Traceback (most recent call last):
+ ...
+ Invalid: That is not a valid URL
+ >>> u.to_python('https://test.com')
+ 'https://test.com'
+ >>> u.to_python('http://test')
+ Traceback (most recent call last):
+ ...
+ Invalid: You must provide a full domain name (like test.com)
+ >>> u.to_python('http://test..com')
+ Traceback (most recent call last):
+ ...
+ Invalid: That is not a valid URL
+ >>> u = URL(add_http=False, check_exists=True)
+ >>> u.to_python('http://google.com')
+ 'http://google.com'
+ >>> u.to_python('google.com')
+ Traceback (most recent call last):
+ ...
+ Invalid: You must start your URL with http://, https://, etc
+ >>> u.to_python('http://www.formencode.org/does/not/exist/page.html')
+ Traceback (most recent call last):
+ ...
+ Invalid: The server responded that the page could not be found
+ >>> u.to_python('http://this.domain.does.not.exist.example.org/test.html')
+ ... # doctest: +ELLIPSIS
+ Traceback (most recent call last):
+ ...
+ Invalid: An error occured when trying to connect to the server: ...
+
+ If you want to allow addresses without a TLD (e.g., ``localhost``) you can do::
+
+ >>> URL(require_tld=False).to_python('http://localhost')
+ 'http://localhost'
+
+ By default, internationalized domain names (IDNA) in Unicode will be
+ accepted and encoded to ASCII using Punycode (as described in RFC 3490).
+ You may set allow_idna to False to change this behavior::
+
+ >>> URL(allow_idna=True).to_python(
+ ... 'http://\\u0433\\u0443\\u0433\\u043b.\\u0440\\u0444')
+ 'http://xn--c1aay4a.xn--p1ai'
+ >>> URL(allow_idna=True, add_http=True).to_python(
+ ... '\\u0433\\u0443\\u0433\\u043b.\\u0440\\u0444')
+ 'http://xn--c1aay4a.xn--p1ai'
+ >>> URL(allow_idna=False).to_python(
+ ... 'http://\\u0433\\u0443\\u0433\\u043b.\\u0440\\u0444')
+ Traceback (most recent call last):
+ ...
+ Invalid: That is not a valid URL
+
+ """
+
+ add_http = True
+ allow_idna = True
+ check_exists = False
+ require_tld = True
+
+ url_re = re.compile(r'''
+ ^(http|https)://
+ (?:[%:\w]*@)? # authenticator
+ (?: # ip or domain
+ (?P<ip>(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))|
+ (?P<domain>[a-z0-9][a-z0-9\-]{,62}\.)* # subdomain
+ (?P<tld>[a-z]{2,63}|xn--[a-z0-9\-]{2,59}) # top level domain
+ )
+ (?::[0-9]{1,5})? # port
+ # files/delims/etc
+ (?P<path>/[a-z0-9\-\._~:/\?#\[\]@!%\$&\'\(\)\*\+,;=]*)?
+ $
+ ''', re.I | re.VERBOSE)
+
+ scheme_re = re.compile(r'^[a-zA-Z]+:')
+
+ messages = dict(
+ noScheme=_('You must start your URL with http://, https://, etc'),
+ badURL=_('That is not a valid URL'),
+ httpError=_('An error occurred when trying to access the URL:'
+ ' %(error)s'),
+ socketError=_('An error occured when trying to connect to the server:'
+ ' %(error)s'),
+ notFound=_('The server responded that the page could not be found'),
+ status=_('The server responded with a bad status code (%(status)s)'),
+ noTLD=_('You must provide a full domain name (like %(domain)s.com)'))
+
+ def _convert_to_python(self, value, state):
+ value = value.strip()
+ if self.add_http:
+ if not self.scheme_re.search(value):
+ value = 'http://' + value
+ if self.allow_idna:
+ value = self._encode_idna(value)
+ match = self.scheme_re.search(value)
+ if not match:
+ raise Invalid(self.message('noScheme', state), value, state)
+ value = match.group(0).lower() + value[len(match.group(0)):]
+ match = self.url_re.search(value)
+ if not match:
+ raise Invalid(self.message('badURL', state), value, state)
+ if self.require_tld and not match.group('domain'):
+ raise Invalid(
+ self.message('noTLD', state, domain=match.group('tld')),
+ value, state)
+ if self.check_exists and value.startswith(('http://', 'https://')):
+ self._check_url_exists(value, state)
+ return value
+
+ def _encode_idna(self, url):
+ global urlparse
+ if urlparse is None:
+ import urllib.parse
+ try:
+ scheme, netloc, path, params, query, fragment = urllib.parse.urlparse(
+ url)
+ except ValueError:
+ return url
+ try:
+ netloc = netloc.encode('idna')
+ if str is str: # Python 3
+ netloc = netloc.decode('ascii')
+ return str(urllib.parse.urlunparse((scheme, netloc,
+ path, params, query, fragment)))
+ except UnicodeError:
+ return url
+
+ def _check_url_exists(self, url, state):
+ global httplib, urlparse, socket
+ if httplib is None:
+ import http.client
+ if urlparse is None:
+ import urllib.parse
+ if socket is None:
+ import socket
+ scheme, netloc, path, params, query, fragment = urllib.parse.urlparse(
+ url, 'http')
+ if scheme == 'https':
+ ConnClass = http.client.HTTPSConnection
+ else:
+ ConnClass = http.client.HTTPConnection
+ try:
+ conn = ConnClass(netloc)
+ if params:
+ path += ';' + params
+ if query:
+ path += '?' + query
+ conn.request('HEAD', path)
+ res = conn.getresponse()
+ except http.client.HTTPException as e:
+ raise Invalid(
+ self.message('httpError', state, error=e), state, url)
+ except socket.error as e:
+ raise Invalid(
+ self.message('socketError', state, error=e), state, url)
+ else:
+ if res.status == 404:
+ raise Invalid(
+ self.message('notFound', state), state, url)
+ if not 200 <= res.status < 500:
+ raise Invalid(
+ self.message('status', state, status=res.status),
+ state, url)
+
+
+class XRI(FancyValidator):
+ r"""
+ Validator for XRIs.
+
+ It supports both i-names and i-numbers, of the first version of the XRI
+ standard.
+
+ ::
+
+ >>> inames = XRI(xri_type="i-name")
+ >>> inames.to_python(" =John.Smith ")
+ '=John.Smith'
+ >>> inames.to_python("@Free.Software.Foundation")
+ '@Free.Software.Foundation'
+ >>> inames.to_python("Python.Software.Foundation")
+ Traceback (most recent call last):
+ ...
+ Invalid: The type of i-name is not defined; it may be either individual or organizational
+ >>> inames.to_python("http://example.org")
+ Traceback (most recent call last):
+ ...
+ Invalid: The type of i-name is not defined; it may be either individual or organizational
+ >>> inames.to_python("=!2C43.1A9F.B6F6.E8E6")
+ Traceback (most recent call last):
+ ...
+ Invalid: "!2C43.1A9F.B6F6.E8E6" is an invalid i-name
+ >>> iname_with_schema = XRI(True, xri_type="i-name")
+ >>> iname_with_schema.to_python("=Richard.Stallman")
+ 'xri://=Richard.Stallman'
+ >>> inames.to_python("=John Smith")
+ Traceback (most recent call last):
+ ...
+ Invalid: "John Smith" is an invalid i-name
+ >>> inumbers = XRI(xri_type="i-number")
+ >>> inumbers.to_python("!!1000!de21.4536.2cb2.8074")
+ '!!1000!de21.4536.2cb2.8074'
+ >>> inumbers.to_python("@!1000.9554.fabd.129c!2847.df3c")
+ '@!1000.9554.fabd.129c!2847.df3c'
+
+ """
+
+ iname_valid_pattern = re.compile(r"""
+ ^
+ [\w]+ # A global alphanumeric i-name
+ (\.[\w]+)* # An i-name with dots
+ (\*[\w]+(\.[\w]+)*)* # A community i-name
+ $
+ """, re.VERBOSE | re.UNICODE)
+
+ iname_invalid_start = re.compile(r"^[\d\.-]", re.UNICODE)
+ """@cvar: These characters must not be at the beggining of the i-name"""
+
+ inumber_pattern = re.compile(r"""
+ ^
+ (
+ [=@]! # It's a personal or organization i-number
+ |
+ !! # It's a network i-number
+ )
+ [\dA-F]{1,4}(\.[\dA-F]{1,4}){0,3} # A global i-number
+ (![\dA-F]{1,4}(\.[\dA-F]{1,4}){0,3})* # Zero or more sub i-numbers
+ $
+ """, re.VERBOSE | re.IGNORECASE)
+
+ messages = dict(
+ noType=_('The type of i-name is not defined;'
+ ' it may be either individual or organizational'),
+ repeatedChar=_('Dots and dashes may not be repeated consecutively'),
+ badIname=_('"%(iname)s" is an invalid i-name'),
+ badInameStart=_('i-names may not start with numbers'
+ ' nor punctuation marks'),
+ badInumber=_('"%(inumber)s" is an invalid i-number'),
+ badType=_('The XRI must be a string (not a %(type)s: %(value)r)'),
+ badXri=_('"%(xri_type)s" is not a valid type of XRI'))
+
+ def __init__(self, add_xri=False, xri_type="i-name", **kwargs):
+ """Create an XRI validator.
+
+ @param add_xri: Should the schema be added if not present?
+ Officially it's optional.
+ @type add_xri: C{bool}
+ @param xri_type: What type of XRI should be validated?
+ Possible values: C{i-name} or C{i-number}.
+ @type xri_type: C{str}
+
+ """
+ self.add_xri = add_xri
+ assert xri_type in ('i-name', 'i-number'), (
+ 'xri_type must be "i-name" or "i-number"')
+ self.xri_type = xri_type
+ super(XRI, self).__init__(**kwargs)
+
+ def _convert_to_python(self, value, state):
+ """Prepend the 'xri://' schema if needed and remove trailing spaces"""
+ value = value.strip()
+ if self.add_xri and not value.startswith('xri://'):
+ value = 'xri://' + value
+ return value
+
+ def _validate_python(self, value, state=None):
+ """Validate an XRI
+
+ @raise Invalid: If at least one of the following conditions in met:
+ - C{value} is not a string.
+ - The XRI is not a personal, organizational or network one.
+ - The relevant validator (i-name or i-number) considers the XRI
+ is not valid.
+
+ """
+ if not isinstance(value, str):
+ raise Invalid(
+ self.message('badType', state,
+ type=str(type(value)), value=value), value, state)
+
+ # Let's remove the schema, if any
+ if value.startswith('xri://'):
+ value = value[6:]
+
+ if not value[0] in ('@', '=') and not (
+ self.xri_type == 'i-number' and value[0] == '!'):
+ raise Invalid(self.message('noType', state), value, state)
+
+ if self.xri_type == 'i-name':
+ self._validate_iname(value, state)
+ else:
+ self._validate_inumber(value, state)
+
+ def _validate_iname(self, iname, state):
+ """Validate an i-name"""
+ # The type is not required here:
+ iname = iname[1:]
+ if '..' in iname or '--' in iname:
+ raise Invalid(self.message('repeatedChar', state), iname, state)
+ if self.iname_invalid_start.match(iname):
+ raise Invalid(self.message('badInameStart', state), iname, state)
+ if not self.iname_valid_pattern.match(iname) or '_' in iname:
+ raise Invalid(
+ self.message('badIname', state, iname=iname), iname, state)
+
+ def _validate_inumber(self, inumber, state):
+ """Validate an i-number"""
+ if not self.__class__.inumber_pattern.match(inumber):
+ raise Invalid(
+ self.message('badInumber', state,
+ inumber=inumber, value=inumber), inumber, state)
+
+
+class OpenId(FancyValidator):
+ r"""
+ OpenId validator.
+
+ ::
+ >>> v = OpenId(add_schema=True)
+ >>> v.to_python(' example.net ')
+ 'http://example.net'
+ >>> v.to_python('@TurboGears')
+ 'xri://@TurboGears'
+ >>> w = OpenId(add_schema=False)
+ >>> w.to_python(' example.net ')
+ Traceback (most recent call last):
+ ...
+ Invalid: "example.net" is not a valid OpenId (it is neither an URL nor an XRI)
+ >>> w.to_python('!!1000')
+ '!!1000'
+ >>> w.to_python('look@me.com')
+ Traceback (most recent call last):
+ ...
+ Invalid: "look@me.com" is not a valid OpenId (it is neither an URL nor an XRI)
+
+ """
+
+ messages = dict(
+ badId=_('"%(id)s" is not a valid OpenId'
+ ' (it is neither an URL nor an XRI)'))
+
+ def __init__(self, add_schema=False, **kwargs):
+ """Create an OpenId validator.
+
+ @param add_schema: Should the schema be added if not present?
+ @type add_schema: C{bool}
+
+ """
+ self.url_validator = URL(add_http=add_schema)
+ self.iname_validator = XRI(add_schema, xri_type="i-name")
+ self.inumber_validator = XRI(add_schema, xri_type="i-number")
+
+ def _convert_to_python(self, value, state):
+ value = value.strip()
+ try:
+ return self.url_validator.to_python(value, state)
+ except Invalid:
+ try:
+ return self.iname_validator.to_python(value, state)
+ except Invalid:
+ try:
+ return self.inumber_validator.to_python(value, state)
+ except Invalid:
+ pass
+ # It's not an OpenId!
+ raise Invalid(self.message('badId', state, id=value), value, state)
+
+ def _validate_python(self, value, state):
+ self._convert_to_python(value, state)
+
+
+def StateProvince(*kw, **kwargs):
+ deprecation_warning("please use formencode.national.USStateProvince")
+ from formencode.national import USStateProvince
+ return USStateProvince(*kw, **kwargs)
+
+
+def PhoneNumber(*kw, **kwargs):
+ deprecation_warning("please use formencode.national.USPhoneNumber")
+ from formencode.national import USPhoneNumber
+ return USPhoneNumber(*kw, **kwargs)
+
+
+def IPhoneNumberValidator(*kw, **kwargs):
+ deprecation_warning(
+ "please use formencode.national.InternationalPhoneNumber")
+ from formencode.national import InternationalPhoneNumber
+ return InternationalPhoneNumber(*kw, **kwargs)
+
+
+class FieldStorageUploadConverter(FancyValidator):
+ """
+ Handles cgi.FieldStorage instances that are file uploads.
+
+ This doesn't do any conversion, but it can detect empty upload
+ fields (which appear like normal fields, but have no filename when
+ no upload was given).
+ """
+ def _convert_to_python(self, value, state=None):
+ if isinstance(value, cgi.FieldStorage):
+ if getattr(value, 'filename', None):
+ return value
+ raise Invalid('invalid', value, state)
+ else:
+ return value
+
+ def is_empty(self, value):
+ if isinstance(value, cgi.FieldStorage):
+ return not bool(getattr(value, 'filename', None))
+ return FancyValidator.is_empty(self, value)
+
+
+class FileUploadKeeper(FancyValidator):
+ """
+ Takes two inputs (a dictionary with keys ``static`` and
+ ``upload``) and converts them into one value on the Python side (a
+ dictionary with ``filename`` and ``content`` keys). The upload
+ takes priority over the static value. The filename may be None if
+ it can't be discovered.
+
+ Handles uploads of both text and ``cgi.FieldStorage`` upload
+ values.
+
+ This is basically for use when you have an upload field, and you
+ want to keep the upload around even if the rest of the form
+ submission fails. When converting *back* to the form submission,
+ there may be extra values ``'original_filename'`` and
+ ``'original_content'``, which may want to use in your form to show
+ the user you still have their content around.
+
+ To use this, make sure you are using variabledecode, then use
+ something like::
+
+ <input type="file" name="myfield.upload">
+ <input type="hidden" name="myfield.static">
+
+ Then in your scheme::
+
+ class MyScheme(Scheme):
+ myfield = FileUploadKeeper()
+
+ Note that big file uploads mean big hidden fields, and lots of
+ bytes passed back and forth in the case of an error.
+ """
+
+ upload_key = 'upload'
+ static_key = 'static'
+
+ def _convert_to_python(self, value, state):
+ upload = value.get(self.upload_key)
+ static = value.get(self.static_key, '').strip()
+ filename = content = None
+ if isinstance(upload, cgi.FieldStorage):
+ filename = upload.filename
+ content = upload.value
+ elif isinstance(upload, str) and upload:
+ filename = None
+ # @@: Should this encode upload if it is unicode?
+ content = upload
+ if not content and static:
+ filename, content = static.split(None, 1)
+ filename = '' if filename == '-' else filename.decode('base64')
+ content = content.decode('base64')
+ return {'filename': filename, 'content': content}
+
+ def _convert_from_python(self, value, state):
+ filename = value.get('filename', '')
+ content = value.get('content', '')
+ if filename or content:
+ result = self.pack_content(filename, content)
+ return {self.upload_key: '',
+ self.static_key: result,
+ 'original_filename': filename,
+ 'original_content': content}
+ else:
+ return {self.upload_key: '',
+ self.static_key: ''}
+
+ def pack_content(self, filename, content):
+ enc_filename = self.base64encode(filename) or '-'
+ enc_content = (content or '').encode('base64')
+ result = '%s %s' % (enc_filename, enc_content)
+ return result
+
+
+class DateConverter(FancyValidator):
+ """
+ Validates and converts a string date, like mm/yy, dd/mm/yy,
+ dd-mm-yy, etc. Using ``month_style`` you can support
+ the three general styles ``mdy`` = ``us`` = ``mm/dd/yyyy``,
+ ``dmy`` = ``euro`` = ``dd/mm/yyyy`` and
+ ``ymd`` = ``iso`` = ``yyyy/mm/dd``.
+
+ Accepts English month names, also abbreviated. Returns value as a
+ datetime object (you can get mx.DateTime objects if you use
+ ``datetime_module='mxDateTime'``). Two year dates are assumed to
+ be within 1950-2020, with dates from 21-49 being ambiguous and
+ signaling an error.
+
+ Use accept_day=False if you just want a month/year (like for a
+ credit card expiration date).
+
+ ::
+
+ >>> d = DateConverter()
+ >>> d.to_python('12/3/09')
+ datetime.date(2009, 12, 3)
+ >>> d.to_python('12/3/2009')
+ datetime.date(2009, 12, 3)
+ >>> d.to_python('2/30/04')
+ Traceback (most recent call last):
+ ...
+ Invalid: That month only has 29 days
+ >>> d.to_python('13/2/05')
+ Traceback (most recent call last):
+ ...
+ Invalid: Please enter a month from 1 to 12
+ >>> d.to_python('1/1/200')
+ Traceback (most recent call last):
+ ...
+ Invalid: Please enter a four-digit year after 1899
+
+ If you change ``month_style`` you can get European-style dates::
+
+ >>> d = DateConverter(month_style='dd/mm/yyyy')
+ >>> date = d.to_python('12/3/09')
+ >>> date
+ datetime.date(2009, 3, 12)
+ >>> d.from_python(date)
+ '12/03/2009'
+ """
+
+ # set to False if you want only month and year
+ accept_day = True
+ # allowed month styles: 'mdy' = 'us', 'dmy' = 'euro', 'ymd' = 'iso'
+ # also allowed: 'mm/dd/yyyy', 'dd/mm/yyyy', 'yyyy/mm/dd'
+ month_style = 'mdy'
+ # preferred separator for reverse conversion: '/', '.' or '-'
+ separator = '/'
+
+ # Use 'datetime' to force the Python datetime module, or
+ # 'mxDateTime' to force the mxDateTime module (None means use
+ # datetime, or if not present mxDateTime)
+ datetime_module = None
+
+ _month_names = {
+ 'jan': 1, 'january': 1,
+ 'feb': 2, 'febuary': 2,
+ 'mar': 3, 'march': 3,
+ 'apr': 4, 'april': 4,
+ 'may': 5,
+ 'jun': 6, 'june': 6,
+ 'jul': 7, 'july': 7,
+ 'aug': 8, 'august': 8,
+ 'sep': 9, 'sept': 9, 'september': 9,
+ 'oct': 10, 'october': 10,
+ 'nov': 11, 'november': 11,
+ 'dec': 12, 'december': 12,
+ }
+
+ _date_re = dict(
+ dmy=re.compile(
+ r'^\s*(\d\d?)[\-\./\\](\d\d?|%s)[\-\./\\](\d\d\d?\d?)\s*$'
+ % '|'.join(_month_names), re.I),
+ mdy=re.compile(
+ r'^\s*(\d\d?|%s)[\-\./\\](\d\d?)[\-\./\\](\d\d\d?\d?)\s*$'
+ % '|'.join(_month_names), re.I),
+ ymd=re.compile(
+ r'^\s*(\d\d\d?\d?)[\-\./\\](\d\d?|%s)[\-\./\\](\d\d?)\s*$'
+ % '|'.join(_month_names), re.I),
+ my=re.compile(
+ r'^\s*(\d\d?|%s)[\-\./\\](\d\d\d?\d?)\s*$'
+ % '|'.join(_month_names), re.I),
+ ym=re.compile(
+ r'^\s*(\d\d\d?\d?)[\-\./\\](\d\d?|%s)\s*$'
+ % '|'.join(_month_names), re.I))
+
+ _formats = dict(d='%d', m='%m', y='%Y')
+
+ _human_formats = dict(d=_('DD'), m=_('MM'), y=_('YYYY'))
+
+ # Feb. should be leap-year aware (but mxDateTime does catch that)
+ _monthDays = {
+ 1: 31, 2: 29, 3: 31, 4: 30, 5: 31, 6: 30, 7: 31, 8: 31,
+ 9: 30, 10: 31, 11: 30, 12: 31}
+
+ messages = dict(
+ badFormat=_('Please enter the date in the form %(format)s'),
+ monthRange=_('Please enter a month from 1 to 12'),
+ invalidDay=_('Please enter a valid day'),
+ dayRange=_('That month only has %(days)i days'),
+ invalidDate=_('That is not a valid day (%(exception)s)'),
+ unknownMonthName=_('Unknown month name: %(month)s'),
+ invalidYear=_('Please enter a number for the year'),
+ fourDigitYear=_('Please enter a four-digit year after 1899'),
+ wrongFormat=_('Please enter the date in the form %(format)s'))
+
+ def __init__(self, *args, **kw):
+ super(DateConverter, self).__init__(*args, **kw)
+ month_style = (self.month_style or DateConverter.month_style).lower()
+ accept_day = bool(self.accept_day)
+ self.accept_day = self.accept_day
+ if month_style in ('mdy',
+ 'md', 'mm/dd/yyyy', 'mm/dd', 'us', 'american'):
+ month_style = 'mdy'
+ elif month_style in ('dmy',
+ 'dm', 'dd/mm/yyyy', 'dd/mm', 'euro', 'european'):
+ month_style = 'dmy'
+ elif month_style in ('ymd',
+ 'ym', 'yyyy/mm/dd', 'yyyy/mm', 'iso', 'china', 'chinese'):
+ month_style = 'ymd'
+ else:
+ raise TypeError('Bad month_style: %r' % month_style)
+ self.month_style = month_style
+ separator = self.separator
+ if not separator or separator == 'auto':
+ separator = dict(mdy='/', dmy='.', ymd='-')[month_style]
+ elif separator not in ('-', '.', '/', '\\'):
+ raise TypeError('Bad separator: %r' % separator)
+ self.separator = separator
+ self.format = separator.join(self._formats[part]
+ for part in month_style if part != 'd' or accept_day)
+ self.human_format = separator.join(self._human_formats[part]
+ for part in month_style if part != 'd' or accept_day)
+
+ def _convert_to_python(self, value, state):
+ self.assert_string(value, state)
+ month_style = self.month_style
+ if not self.accept_day:
+ month_style = 'ym' if month_style == 'ymd' else 'my'
+ match = self._date_re[month_style].search(value)
+ if not match:
+ raise Invalid(
+ self.message('badFormat', state,
+ format=self.human_format), value, state)
+ groups = match.groups()
+ if self.accept_day:
+ if month_style == 'mdy':
+ month, day, year = groups
+ elif month_style == 'dmy':
+ day, month, year = groups
+ else:
+ year, month, day = groups
+ day = int(day)
+ if not 1 <= day <= 31:
+ raise Invalid(self.message('invalidDay', state), value, state)
+ else:
+ day = 1
+ if month_style == 'my':
+ month, year = groups
+ else:
+ year, month = groups
+ month = self.make_month(month, state)
+ if not 1 <= month <= 12:
+ raise Invalid(self.message('monthRange', state), value, state)
+ if self._monthDays[month] < day:
+ raise Invalid(
+ self.message('dayRange', state,
+ days=self._monthDays[month]), value, state)
+ year = self.make_year(year, state)
+ dt_mod = import_datetime(self.datetime_module)
+ try:
+ return datetime_makedate(dt_mod, year, month, day)
+ except ValueError as v:
+ raise Invalid(
+ self.message('invalidDate', state,
+ exception=str(v)), value, state)
+
+ def make_month(self, value, state):
+ try:
+ return int(value)
+ except ValueError:
+ try:
+ return self._month_names[value.lower().strip()]
+ except KeyError:
+ raise Invalid(
+ self.message('unknownMonthName', state,
+ month=value), value, state)
+
+ def make_year(self, year, state):
+ try:
+ year = int(year)
+ except ValueError:
+ raise Invalid(self.message('invalidYear', state), year, state)
+ if year <= 20:
+ year += 2000
+ elif 50 <= year < 100:
+ year += 1900
+ if 20 < year < 50 or 99 < year < 1900:
+ raise Invalid(self.message('fourDigitYear', state), year, state)
+ return year
+
+ def _convert_from_python(self, value, state):
+ if self.if_empty is not NoDefault and not value:
+ return ''
+ return value.strftime(self.format)
+
+
+class TimeConverter(FancyValidator):
+ """
+ Converts times in the format HH:MM:SSampm to (h, m, s).
+ Seconds are optional.
+
+ For ampm, set use_ampm = True. For seconds, use_seconds = True.
+ Use 'optional' for either of these to make them optional.
+
+ Examples::
+
+ >>> tim = TimeConverter()
+ >>> tim.to_python('8:30')
+ (8, 30)
+ >>> tim.to_python('20:30')
+ (20, 30)
+ >>> tim.to_python('30:00')
+ Traceback (most recent call last):
+ ...
+ Invalid: You must enter an hour in the range 0-23
+ >>> tim.to_python('13:00pm')
+ Traceback (most recent call last):
+ ...
+ Invalid: You must enter an hour in the range 1-12
+ >>> tim.to_python('12:-1')
+ Traceback (most recent call last):
+ ...
+ Invalid: You must enter a minute in the range 0-59
+ >>> tim.to_python('12:02pm')
+ (12, 2)
+ >>> tim.to_python('12:02am')
+ (0, 2)
+ >>> tim.to_python('1:00PM')
+ (13, 0)
+ >>> tim.from_python((13, 0))
+ '13:00:00'
+ >>> tim2 = tim(use_ampm=True, use_seconds=False)
+ >>> tim2.from_python((13, 0))
+ '1:00pm'
+ >>> tim2.from_python((0, 0))
+ '12:00am'
+ >>> tim2.from_python((12, 0))
+ '12:00pm'
+
+ Examples with ``datetime.time``::
+
+ >>> v = TimeConverter(use_datetime=True)
+ >>> a = v.to_python('18:00')
+ >>> a
+ datetime.time(18, 0)
+ >>> b = v.to_python('30:00')
+ Traceback (most recent call last):
+ ...
+ Invalid: You must enter an hour in the range 0-23
+ >>> v2 = TimeConverter(prefer_ampm=True, use_datetime=True)
+ >>> v2.from_python(a)
+ '6:00:00pm'
+ >>> v3 = TimeConverter(prefer_ampm=True,
+ ... use_seconds=False, use_datetime=True)
+ >>> a = v3.to_python('18:00')
+ >>> a
+ datetime.time(18, 0)
+ >>> v3.from_python(a)
+ '6:00pm'
+ >>> a = v3.to_python('18:00:00')
+ Traceback (most recent call last):
+ ...
+ Invalid: You may not enter seconds
+ """
+
+ use_ampm = 'optional'
+ prefer_ampm = False
+ use_seconds = 'optional'
+ use_datetime = False
+ # This can be set to make it prefer mxDateTime:
+ datetime_module = None
+
+ messages = dict(
+ noAMPM=_('You must indicate AM or PM'),
+ tooManyColon=_('There are too many :\'s'),
+ noSeconds=_('You may not enter seconds'),
+ secondsRequired=_('You must enter seconds'),
+ minutesRequired=_('You must enter minutes (after a :)'),
+ badNumber=_('The %(part)s value you gave is not a number: %(number)r'),
+ badHour=_('You must enter an hour in the range %(range)s'),
+ badMinute=_('You must enter a minute in the range 0-59'),
+ badSecond=_('You must enter a second in the range 0-59'))
+
+ def _convert_to_python(self, value, state):
+ result = self._to_python_tuple(value, state)
+ if self.use_datetime:
+ dt_mod = import_datetime(self.datetime_module)
+ time_class = datetime_time(dt_mod)
+ return time_class(*result)
+ else:
+ return result
+
+ def _to_python_tuple(self, value, state):
+ time = value.strip()
+ explicit_ampm = False
+ if self.use_ampm:
+ last_two = time[-2:].lower()
+ if last_two not in ('am', 'pm'):
+ if self.use_ampm != 'optional':
+ raise Invalid(self.message('noAMPM', state), value, state)
+ offset = 0
+ else:
+ explicit_ampm = True
+ offset = 12 if last_two == 'pm' else 0
+ time = time[:-2]
+ else:
+ offset = 0
+ parts = time.split(':', 3)
+ if len(parts) > 3:
+ raise Invalid(self.message('tooManyColon', state), value, state)
+ if len(parts) == 3 and not self.use_seconds:
+ raise Invalid(self.message('noSeconds', state), value, state)
+ if (len(parts) == 2
+ and self.use_seconds and self.use_seconds != 'optional'):
+ raise Invalid(self.message('secondsRequired', state), value, state)
+ if len(parts) == 1:
+ raise Invalid(self.message('minutesRequired', state), value, state)
+ try:
+ hour = int(parts[0])
+ except ValueError:
+ raise Invalid(
+ self.message('badNumber', state,
+ number=parts[0], part='hour'), value, state)
+ if explicit_ampm:
+ if not 1 <= hour <= 12:
+ raise Invalid(
+ self.message('badHour', state,
+ number=hour, range='1-12'), value, state)
+ if hour == 12 and offset == 12:
+ # 12pm == 12
+ pass
+ elif hour == 12 and offset == 0:
+ # 12am == 0
+ hour = 0
+ else:
+ hour += offset
+ else:
+ if not 0 <= hour < 24:
+ raise Invalid(
+ self.message('badHour', state,
+ number=hour, range='0-23'), value, state)
+ try:
+ minute = int(parts[1])
+ except ValueError:
+ raise Invalid(
+ self.message('badNumber', state,
+ number=parts[1], part='minute'), value, state)
+ if not 0 <= minute < 60:
+ raise Invalid(
+ self.message('badMinute', state, number=minute),
+ value, state)
+ if len(parts) == 3:
+ try:
+ second = int(parts[2])
+ except ValueError:
+ raise Invalid(
+ self.message('badNumber', state,
+ number=parts[2], part='second'), value, state)
+ if not 0 <= second < 60:
+ raise Invalid(
+ self.message('badSecond', state, number=second),
+ value, state)
+ else:
+ second = None
+ if second is None:
+ return (hour, minute)
+ else:
+ return (hour, minute, second)
+
+ def _convert_from_python(self, value, state):
+ if isinstance(value, str):
+ return value
+ if hasattr(value, 'hour'):
+ hour, minute = value.hour, value.minute
+ second = value.second
+ elif len(value) == 3:
+ hour, minute, second = value
+ elif len(value) == 2:
+ hour, minute = value
+ second = 0
+ ampm = ''
+ if (self.use_ampm == 'optional' and self.prefer_ampm) or (
+ self.use_ampm and self.use_ampm != 'optional'):
+ ampm = 'am'
+ if hour > 12:
+ hour -= 12
+ ampm = 'pm'
+ elif hour == 12:
+ ampm = 'pm'
+ elif hour == 0:
+ hour = 12
+ if self.use_seconds:
+ return '%i:%02i:%02i%s' % (hour, minute, second, ampm)
+ else:
+ return '%i:%02i%s' % (hour, minute, ampm)
+
+
+def PostalCode(*kw, **kwargs):
+ deprecation_warning("please use formencode.national.USPostalCode")
+ from formencode.national import USPostalCode
+ return USPostalCode(*kw, **kwargs)
+
+
+class StripField(FancyValidator):
+ """
+ Take a field from a dictionary, removing the key from the dictionary.
+
+ ``name`` is the key. The field value and a new copy of the dictionary
+ with that field removed are returned.
+
+ >>> StripField('test').to_python({'a': 1, 'test': 2})
+ (2, {'a': 1})
+ >>> StripField('test').to_python({})
+ Traceback (most recent call last):
+ ...
+ Invalid: The name 'test' is missing
+
+ """
+
+ __unpackargs__ = ('name',)
+
+ messages = dict(
+ missing=_('The name %(name)s is missing'))
+
+ def _convert_to_python(self, valueDict, state):
+ v = valueDict.copy()
+ try:
+ field = v.pop(self.name)
+ except KeyError:
+ raise Invalid(
+ self.message('missing', state, name=repr(self.name)),
+ valueDict, state)
+ return field, v
+
+ def is_empty(self, value):
+ # empty dictionaries don't really apply here
+ return False
+
+
+class StringBool(FancyValidator): # originally from TurboGears 1
+ """
+ Converts a string to a boolean.
+
+ Values like 'true' and 'false' are considered True and False,
+ respectively; anything in ``true_values`` is true, anything in
+ ``false_values`` is false, case-insensitive). The first item of
+ those lists is considered the preferred form.
+
+ ::
+
+ >>> s = StringBool()
+ >>> s.to_python('yes'), s.to_python('no')
+ (True, False)
+ >>> s.to_python(1), s.to_python('N')
+ (True, False)
+ >>> s.to_python('ye')
+ Traceback (most recent call last):
+ ...
+ Invalid: Value should be 'true' or 'false'
+ """
+
+ true_values = ['true', 't', 'yes', 'y', 'on', '1']
+ false_values = ['false', 'f', 'no', 'n', 'off', '0']
+
+ messages = dict(
+ string=_('Value should be %(true)r or %(false)r'))
+
+ def _convert_to_python(self, value, state):
+ if isinstance(value, str):
+ value = value.strip().lower()
+ if value in self.true_values:
+ return True
+ if not value or value in self.false_values:
+ return False
+ raise Invalid(
+ self.message('string', state,
+ true=self.true_values[0], false=self.false_values[0]),
+ value, state)
+ return bool(value)
+
+ def _convert_from_python(self, value, state):
+ return (self.true_values if value else self.false_values)[0]
+
+# Should deprecate:
+StringBoolean = StringBool
+
+
+class SignedString(FancyValidator):
+ """
+ Encodes a string into a signed string, and base64 encodes both the
+ signature string and a random nonce.
+
+ It is up to you to provide a secret, and to keep the secret handy
+ and consistent.
+ """
+
+ messages = dict(
+ malformed=_('Value does not contain a signature'),
+ badsig=_('Signature is not correct'))
+
+ secret = None
+ nonce_length = 4
+
+ def _convert_to_python(self, value, state):
+ global sha1
+ if not sha1:
+ from hashlib import sha1
+ assert self.secret is not None, "You must give a secret"
+ parts = value.split(None, 1)
+ if not parts or len(parts) == 1:
+ raise Invalid(self.message('malformed', state), value, state)
+ sig, rest = parts
+ sig = sig.decode('base64')
+ rest = rest.decode('base64')
+ nonce = rest[:self.nonce_length]
+ rest = rest[self.nonce_length:]
+ expected = sha1(str(self.secret) + nonce + rest).digest()
+ if expected != sig:
+ raise Invalid(self.message('badsig', state), value, state)
+ return rest
+
+ def _convert_from_python(self, value, state):
+ global sha1
+ if not sha1:
+ from hashlib import sha1
+ nonce = self.make_nonce()
+ value = str(value)
+ digest = sha1(self.secret + nonce + value).digest()
+ return self.encode(digest) + ' ' + self.encode(nonce + value)
+
+ def encode(self, value):
+ return value.encode('base64').strip().replace('\n', '')
+
+ def make_nonce(self):
+ global random
+ if not random:
+ import random
+ return ''.join(chr(random.randrange(256))
+ for _i in range(self.nonce_length))
+
+
+class IPAddress(FancyValidator):
+ """
+ Formencode validator to check whether a string is a correct IP address.
+
+ Examples::
+
+ >>> ip = IPAddress()
+ >>> ip.to_python('127.0.0.1')
+ '127.0.0.1'
+ >>> ip.to_python('299.0.0.1')
+ Traceback (most recent call last):
+ ...
+ Invalid: The octets must be within the range of 0-255 (not '299')
+ >>> ip.to_python('192.168.0.1/1')
+ Traceback (most recent call last):
+ ...
+ Invalid: Please enter a valid IP address (a.b.c.d)
+ >>> ip.to_python('asdf')
+ Traceback (most recent call last):
+ ...
+ Invalid: Please enter a valid IP address (a.b.c.d)
+ """
+
+ messages = dict(
+ badFormat=_('Please enter a valid IP address (a.b.c.d)'),
+ leadingZeros=_('The octets must not have leading zeros'),
+ illegalOctets=_('The octets must be within the range of 0-255'
+ ' (not %(octet)r)'))
+
+ leading_zeros = False
+
+ def _validate_python(self, value, state=None):
+ try:
+ if not value:
+ raise ValueError
+ octets = value.split('.', 5)
+ # Only 4 octets?
+ if len(octets) != 4:
+ raise ValueError
+ # Correct octets?
+ for octet in octets:
+ if octet.startswith('0') and octet != '0':
+ if not self.leading_zeros:
+ raise Invalid(
+ self.message('leadingZeros', state), value, state)
+ # strip zeros so this won't be an octal number
+ octet = octet.lstrip('0')
+ if not 0 <= int(octet) < 256:
+ raise Invalid(
+ self.message('illegalOctets', state, octet=octet),
+ value, state)
+ # Splitting faild: wrong syntax
+ except ValueError:
+ raise Invalid(self.message('badFormat', state), value, state)
+
+
+class CIDR(IPAddress):
+ """
+ Formencode validator to check whether a string is in correct CIDR
+ notation (IP address, or IP address plus /mask).
+
+ Examples::
+
+ >>> cidr = CIDR()
+ >>> cidr.to_python('127.0.0.1')
+ '127.0.0.1'
+ >>> cidr.to_python('299.0.0.1')
+ Traceback (most recent call last):
+ ...
+ Invalid: The octets must be within the range of 0-255 (not '299')
+ >>> cidr.to_python('192.168.0.1/1')
+ Traceback (most recent call last):
+ ...
+ Invalid: The network size (bits) must be within the range of 8-32 (not '1')
+ >>> cidr.to_python('asdf')
+ Traceback (most recent call last):
+ ...
+ Invalid: Please enter a valid IP address (a.b.c.d) or IP network (a.b.c.d/e)
+ """
+
+ messages = dict(IPAddress._messages,
+ badFormat=_('Please enter a valid IP address (a.b.c.d)'
+ ' or IP network (a.b.c.d/e)'),
+ illegalBits=_('The network size (bits) must be within the range'
+ ' of 8-32 (not %(bits)r)'))
+
+ def _validate_python(self, value, state):
+ try:
+ # Split into octets and bits
+ if '/' in value: # a.b.c.d/e
+ addr, bits = value.split('/')
+ else: # a.b.c.d
+ addr, bits = value, 32
+ # Use IPAddress validator to validate the IP part
+ IPAddress._validate_python(self, addr, state)
+ # Bits (netmask) correct?
+ if not 8 <= int(bits) <= 32:
+ raise Invalid(
+ self.message('illegalBits', state, bits=bits),
+ value, state)
+ # Splitting faild: wrong syntax
+ except ValueError:
+ raise Invalid(self.message('badFormat', state), value, state)
+
+
+class MACAddress(FancyValidator):
+ """
+ Formencode validator to check whether a string is a correct hardware
+ (MAC) address.
+
+ Examples::
+
+ >>> mac = MACAddress()
+ >>> mac.to_python('aa:bb:cc:dd:ee:ff')
+ 'aabbccddeeff'
+ >>> mac.to_python('aa:bb:cc:dd:ee:ff:e')
+ Traceback (most recent call last):
+ ...
+ Invalid: A MAC address must contain 12 digits and A-F; the value you gave has 13 characters
+ >>> mac.to_python('aa:bb:cc:dd:ee:fx')
+ Traceback (most recent call last):
+ ...
+ Invalid: MAC addresses may only contain 0-9 and A-F (and optionally :), not 'x'
+ >>> MACAddress(add_colons=True).to_python('aabbccddeeff')
+ 'aa:bb:cc:dd:ee:ff'
+ """
+
+ strip = True
+ valid_characters = '0123456789abcdefABCDEF'
+ add_colons = False
+
+ messages = dict(
+ badLength=_('A MAC address must contain 12 digits and A-F;'
+ ' the value you gave has %(length)s characters'),
+ badCharacter=_('MAC addresses may only contain 0-9 and A-F'
+ ' (and optionally :), not %(char)r'))
+
+ def _convert_to_python(self, value, state):
+ address = value.replace(':', '').lower() # remove colons
+ if len(address) != 12:
+ raise Invalid(
+ self.message('badLength', state,
+ length=len(address)), address, state)
+ for char in address:
+ if char not in self.valid_characters:
+ raise Invalid(
+ self.message('badCharacter', state,
+ char=char), address, state)
+ if self.add_colons:
+ address = '%s:%s:%s:%s:%s:%s' % (
+ address[0:2], address[2:4], address[4:6],
+ address[6:8], address[8:10], address[10:12])
+ return address
+
+ _convert_from_python = _convert_to_python
+
+
+class FormValidator(FancyValidator):
+ """
+ A FormValidator is something that can be chained with a Schema.
+
+ Unlike normal chaining the FormValidator can validate forms that
+ aren't entirely valid.
+
+ The important method is .validate(), of course. It gets passed a
+ dictionary of the (processed) values from the form. If you have
+ .validate_partial_form set to True, then it will get the incomplete
+ values as well -- check with the "in" operator if the form was able
+ to process any particular field.
+
+ Anyway, .validate() should return a string or a dictionary. If a
+ string, it's an error message that applies to the whole form. If
+ not, then it should be a dictionary of fieldName: errorMessage.
+ The special key "form" is the error message for the form as a whole
+ (i.e., a string is equivalent to {"form": string}).
+
+ Returns None on no errors.
+ """
+
+ validate_partial_form = False
+
+ validate_partial_python = None
+ validate_partial_other = None
+
+ def is_empty(self, value):
+ return False
+
+ def field_is_empty(self, value):
+ return is_empty(value)
+
+
+class RequireIfMissing(FormValidator):
+ """
+ Require one field based on another field being present or missing.
+
+ This validator is applied to a form, not an individual field (usually
+ using a Schema's ``pre_validators`` or ``chained_validators``) and is
+ available under both names ``RequireIfMissing`` and ``RequireIfPresent``.
+
+ If you provide a ``missing`` value (a string key name) then
+ if that field is missing the field must be entered.
+ This gives you an either/or situation.
+
+ If you provide a ``present`` value (another string key name) then
+ if that field is present, the required field must also be present.
+
+ ::
+
+ >>> from formencode import validators
+ >>> v = validators.RequireIfPresent('phone_type', present='phone')
+ >>> v.to_python(dict(phone_type='', phone='510 420 4577'))
+ Traceback (most recent call last):
+ ...
+ Invalid: You must give a value for phone_type
+ >>> v.to_python(dict(phone=''))
+ {'phone': ''}
+
+ Note that if you have a validator on the optionally-required
+ field, you should probably use ``if_missing=None``. This way you
+ won't get an error from the Schema about a missing value. For example::
+
+ class PhoneInput(Schema):
+ phone = PhoneNumber()
+ phone_type = String(if_missing=None)
+ chained_validators = [RequireIfPresent('phone_type', present='phone')]
+ """
+
+ # Field that potentially is required:
+ required = None
+ # If this field is missing, then it is required:
+ missing = None
+ # If this field is present, then it is required:
+ present = None
+
+ __unpackargs__ = ('required',)
+
+ def _convert_to_python(self, value_dict, state):
+ is_empty = self.field_is_empty
+ if is_empty(value_dict.get(self.required)) and (
+ (self.missing and is_empty(value_dict.get(self.missing))) or
+ (self.present and not is_empty(value_dict.get(self.present)))):
+ raise Invalid(
+ _('You must give a value for %s') % self.required,
+ value_dict, state,
+ error_dict={self.required:
+ Invalid(self.message('empty', state),
+ value_dict.get(self.required), state)})
+ return value_dict
+
+RequireIfPresent = RequireIfMissing
+
+class RequireIfMatching(FormValidator):
+ """
+ Require a list of fields based on the value of another field.
+
+ This validator is applied to a form, not an individual field (usually
+ using a Schema's ``pre_validators`` or ``chained_validators``).
+
+ You provide a field name, an expected value and a list of required fields
+ (a list of string key names). If the value of the field, if present,
+ matches the value of ``expected_value``, then the validator will raise an
+ ``Invalid`` exception for every field in ``required_fields`` that is
+ missing.
+
+ ::
+
+ >>> from formencode import validators
+ >>> v = validators.RequireIfMatching('phone_type', expected_value='mobile', required_fields=['mobile'])
+ >>> v.to_python(dict(phone_type='mobile'))
+ Traceback (most recent call last):
+ ...
+ formencode.api.Invalid: You must give a value for mobile
+ >>> v.to_python(dict(phone_type='someothervalue'))
+ {'phone_type': 'someothervalue'}
+ """
+
+ # Field that we will check for its value:
+ field = None
+ # Value that the field shall have
+ expected_value = None
+ # If this field is present, then these fields are required:
+ required_fields = []
+
+ __unpackargs__ = ('field', 'expected_value')
+
+ def _convert_to_python(self, value_dict, state):
+ is_empty = self.field_is_empty
+
+ if self.field in value_dict and value_dict.get(self.field) == self.expected_value:
+ for required_field in self.required_fields:
+ if required_field not in value_dict or is_empty(value_dict.get(required_field)):
+ raise Invalid(
+ _('You must give a value for %s') % required_field,
+ value_dict, state,
+ error_dict={required_field:
+ Invalid(self.message('empty', state),
+ value_dict.get(required_field), state)})
+ return value_dict
+
+class FieldsMatch(FormValidator):
+ """
+ Tests that the given fields match, i.e., are identical. Useful
+ for password+confirmation fields. Pass the list of field names in
+ as `field_names`.
+
+ ::
+
+ >>> f = FieldsMatch('pass', 'conf')
+ >>> sorted(f.to_python({'pass': 'xx', 'conf': 'xx'}).items())
+ [('conf', 'xx'), ('pass', 'xx')]
+ >>> f.to_python({'pass': 'xx', 'conf': 'yy'})
+ Traceback (most recent call last):
+ ...
+ Invalid: conf: Fields do not match
+ """
+
+ show_match = False
+ field_names = None
+ validate_partial_form = True
+
+ __unpackargs__ = ('*', 'field_names')
+
+ messages = dict(
+ invalid=_('Fields do not match (should be %(match)s)'),
+ invalidNoMatch=_('Fields do not match'),
+ notDict=_('Fields should be a dictionary'))
+
+ def __init__(self, *args, **kw):
+ super(FieldsMatch, self).__init__(*args, **kw)
+ if len(self.field_names) < 2:
+ raise TypeError('FieldsMatch() requires at least two field names')
+
+ def validate_partial(self, field_dict, state):
+ for name in self.field_names:
+ if name not in field_dict:
+ return
+ self._validate_python(field_dict, state)
+
+ def _validate_python(self, field_dict, state):
+ try:
+ ref = field_dict[self.field_names[0]]
+ except TypeError:
+ # Generally because field_dict isn't a dict
+ raise Invalid(self.message('notDict', state), field_dict, state)
+ except KeyError:
+ ref = ''
+ errors = {}
+ for name in self.field_names[1:]:
+ if field_dict.get(name, '') != ref:
+ if self.show_match:
+ errors[name] = self.message('invalid', state,
+ match=ref)
+ else:
+ errors[name] = self.message('invalidNoMatch', state)
+ if errors:
+ error_list = sorted(errors.items())
+ error_message = '<br>\n'.join(
+ '%s: %s' % (name, value) for name, value in error_list)
+ raise Invalid(error_message, field_dict, state, error_dict=errors)
+
+
+class CreditCardValidator(FormValidator):
+ """
+ Checks that credit card numbers are valid (if not real).
+
+ You pass in the name of the field that has the credit card
+ type and the field with the credit card number. The credit
+ card type should be one of "visa", "mastercard", "amex",
+ "dinersclub", "discover", "jcb".
+
+ You must check the expiration date yourself (there is no
+ relation between CC number/types and expiration dates).
+
+ ::
+
+ >>> cc = CreditCardValidator()
+ >>> sorted(cc.to_python({'ccType': 'visa', 'ccNumber': '4111111111111111'}).items())
+ [('ccNumber', '4111111111111111'), ('ccType', 'visa')]
+ >>> cc.to_python({'ccType': 'visa', 'ccNumber': '411111111111111'})
+ Traceback (most recent call last):
+ ...
+ Invalid: ccNumber: You did not enter a valid number of digits
+ >>> cc.to_python({'ccType': 'visa', 'ccNumber': '411111111111112'})
+ Traceback (most recent call last):
+ ...
+ Invalid: ccNumber: You did not enter a valid number of digits
+ >>> cc().to_python({})
+ Traceback (most recent call last):
+ ...
+ Invalid: The field ccType is missing
+ """
+
+ validate_partial_form = True
+
+ cc_type_field = 'ccType'
+ cc_number_field = 'ccNumber'
+
+ __unpackargs__ = ('cc_type_field', 'cc_number_field')
+
+ messages = dict(
+ notANumber=_('Please enter only the number, no other characters'),
+ badLength=_('You did not enter a valid number of digits'),
+ invalidNumber=_('That number is not valid'),
+ missing_key=_('The field %(key)s is missing'))
+
+ def validate_partial(self, field_dict, state):
+ if not field_dict.get(self.cc_type_field, None) \
+ or not field_dict.get(self.cc_number_field, None):
+ return None
+ self._validate_python(field_dict, state)
+
+ def _validate_python(self, field_dict, state):
+ errors = self._validateReturn(field_dict, state)
+ if errors:
+ error_list = sorted(errors.items())
+ raise Invalid(
+ '<br>\n'.join('%s: %s' % (name, value)
+ for name, value in error_list),
+ field_dict, state, error_dict=errors)
+
+ def _validateReturn(self, field_dict, state):
+ for field in self.cc_type_field, self.cc_number_field:
+ if field not in field_dict:
+ raise Invalid(
+ self.message('missing_key', state, key=field),
+ field_dict, state)
+ ccType = field_dict[self.cc_type_field].lower().strip()
+ number = field_dict[self.cc_number_field].strip()
+ number = number.replace(' ', '')
+ number = number.replace('-', '')
+ try:
+ int(number)
+ except ValueError:
+ return {self.cc_number_field: self.message('notANumber', state)}
+ assert ccType in self._cardInfo, (
+ "I can't validate that type of credit card")
+ foundValid = False
+ validLength = False
+ for prefix, length in self._cardInfo[ccType]:
+ if len(number) == length:
+ validLength = True
+ if number.startswith(prefix):
+ foundValid = True
+ break
+ if not validLength:
+ return {self.cc_number_field: self.message('badLength', state)}
+ if not foundValid:
+ return {self.cc_number_field: self.message('invalidNumber', state)}
+ if not self._validateMod10(number):
+ return {self.cc_number_field: self.message('invalidNumber', state)}
+ return None
+
+ def _validateMod10(self, s):
+ """Check string with the mod 10 algorithm (aka "Luhn formula")."""
+ checksum, factor = 0, 1
+ for c in reversed(s):
+ for c in str(factor * int(c)):
+ checksum += int(c)
+ factor = 3 - factor
+ return checksum % 10 == 0
+
+ _cardInfo = {
+ "visa": [('4', 16),
+ ('4', 13)],
+ "mastercard": [('51', 16),
+ ('52', 16),
+ ('53', 16),
+ ('54', 16),
+ ('55', 16)],
+ "discover": [('6011', 16)],
+ "amex": [('34', 15),
+ ('37', 15)],
+ "dinersclub": [('300', 14),
+ ('301', 14),
+ ('302', 14),
+ ('303', 14),
+ ('304', 14),
+ ('305', 14),
+ ('36', 14),
+ ('38', 14)],
+ "jcb": [('3', 16),
+ ('2131', 15),
+ ('1800', 15)],
+ }
+
+
+class CreditCardExpires(FormValidator):
+ """
+ Checks that credit card expiration date is valid relative to
+ the current date.
+
+ You pass in the name of the field that has the credit card
+ expiration month and the field with the credit card expiration
+ year.
+
+ ::
+
+ >>> ed = CreditCardExpires()
+ >>> sorted(ed.to_python({'ccExpiresMonth': '11', 'ccExpiresYear': '2250'}).items())
+ [('ccExpiresMonth', '11'), ('ccExpiresYear', '2250')]
+ >>> ed.to_python({'ccExpiresMonth': '10', 'ccExpiresYear': '2005'})
+ Traceback (most recent call last):
+ ...
+ Invalid: ccExpiresMonth: Invalid Expiration Date<br>
+ ccExpiresYear: Invalid Expiration Date
+ """
+
+ validate_partial_form = True
+
+ cc_expires_month_field = 'ccExpiresMonth'
+ cc_expires_year_field = 'ccExpiresYear'
+
+ __unpackargs__ = ('cc_expires_month_field', 'cc_expires_year_field')
+
+ datetime_module = None
+
+ messages = dict(
+ notANumber=_('Please enter numbers only for month and year'),
+ invalidNumber=_('Invalid Expiration Date'))
+
+ def validate_partial(self, field_dict, state):
+ if not field_dict.get(self.cc_expires_month_field, None) \
+ or not field_dict.get(self.cc_expires_year_field, None):
+ return None
+ self._validate_python(field_dict, state)
+
+ def _validate_python(self, field_dict, state):
+ errors = self._validateReturn(field_dict, state)
+ if errors:
+ error_list = sorted(errors.items())
+ raise Invalid(
+ '<br>\n'.join('%s: %s' % (name, value)
+ for name, value in error_list),
+ field_dict, state, error_dict=errors)
+
+ def _validateReturn(self, field_dict, state):
+ ccExpiresMonth = str(field_dict[self.cc_expires_month_field]).strip()
+ ccExpiresYear = str(field_dict[self.cc_expires_year_field]).strip()
+
+ try:
+ ccExpiresMonth = int(ccExpiresMonth)
+ ccExpiresYear = int(ccExpiresYear)
+ dt_mod = import_datetime(self.datetime_module)
+ now = datetime_now(dt_mod)
+ today = datetime_makedate(dt_mod, now.year, now.month, now.day)
+ next_month = ccExpiresMonth % 12 + 1
+ next_month_year = ccExpiresYear
+ if next_month == 1:
+ next_month_year += 1
+ expires_date = datetime_makedate(
+ dt_mod, next_month_year, next_month, 1)
+ assert expires_date > today
+ except ValueError:
+ return {self.cc_expires_month_field:
+ self.message('notANumber', state),
+ self.cc_expires_year_field:
+ self.message('notANumber', state)}
+ except AssertionError:
+ return {self.cc_expires_month_field:
+ self.message('invalidNumber', state),
+ self.cc_expires_year_field:
+ self.message('invalidNumber', state)}
+
+
+class CreditCardSecurityCode(FormValidator):
+ """
+ Checks that credit card security code has the correct number
+ of digits for the given credit card type.
+
+ You pass in the name of the field that has the credit card
+ type and the field with the credit card security code.
+
+ ::
+
+ >>> code = CreditCardSecurityCode()
+ >>> sorted(code.to_python({'ccType': 'visa', 'ccCode': '111'}).items())
+ [('ccCode', '111'), ('ccType', 'visa')]
+ >>> code.to_python({'ccType': 'visa', 'ccCode': '1111'})
+ Traceback (most recent call last):
+ ...
+ Invalid: ccCode: Invalid credit card security code length
+ """
+
+ validate_partial_form = True
+
+ cc_type_field = 'ccType'
+ cc_code_field = 'ccCode'
+
+ __unpackargs__ = ('cc_type_field', 'cc_code_field')
+
+ messages = dict(
+ notANumber=_('Please enter numbers only for credit card security code'),
+ badLength=_('Invalid credit card security code length'))
+
+ def validate_partial(self, field_dict, state):
+ if (not field_dict.get(self.cc_type_field, None)
+ or not field_dict.get(self.cc_code_field, None)):
+ return None
+ self._validate_python(field_dict, state)
+
+ def _validate_python(self, field_dict, state):
+ errors = self._validateReturn(field_dict, state)
+ if errors:
+ error_list = sorted(errors.items())
+ raise Invalid(
+ '<br>\n'.join('%s: %s' % (name, value)
+ for name, value in error_list),
+ field_dict, state, error_dict=errors)
+
+ def _validateReturn(self, field_dict, state):
+ ccType = str(field_dict[self.cc_type_field]).strip()
+ ccCode = str(field_dict[self.cc_code_field]).strip()
+ try:
+ int(ccCode)
+ except ValueError:
+ return {self.cc_code_field: self.message('notANumber', state)}
+ length = self._cardInfo[ccType]
+ if len(ccCode) != length:
+ return {self.cc_code_field: self.message('badLength', state)}
+
+ # key = credit card type, value = length of security code
+ _cardInfo = dict(visa=3, mastercard=3, discover=3, amex=4)
+
+
+def validators():
+ """Return the names of all validators in this module."""
+ return [name for name, value in globals().items()
+ if isinstance(value, type) and issubclass(value, Validator)]
+
+__all__ = ['Invalid'] + validators()
+
projects / m_librarian.git / commitdiff