def _check_range(self, value): assert isinstance(value, (int, long)) if self.min_value is not None and value < self.min_value: raise FieldValueError(public_message=( u'{} is lesser than {}'.format(value, self.min_value))) if self.max_value is not None and value > self.max_value: raise FieldValueError(public_message=( u'{} is greater than {}'.format(value, self.max_value)))
def make_val_ldap_safe(val): val = val.strip() if val.startswith('#'): raise FieldValueError( public_message='Value: {value!r} cannot start with "#" symbol.'.format(value=val)) illegal_char = _check_for_illegal_chars(illegal_characters_for_ldap, val) if illegal_char is not False: raise FieldValueError( public_message='Value: {value!r} contains illegal character: {char!r}.'.format( value=val, char=illegal_char)) return val
def to_stripped(val): if not isinstance(val, basestring): raise FieldValueError(public_message='Illegal type of value for a string-type field.') if isinstance(val, str): try: val = val.decode('utf-8', 'strict') except UnicodeDecodeError as exc: raise FieldValueError( public_message=invalid_field_template_msg.format(value=val, exc=exc)) assert isinstance(val, unicode) return val.strip()
def _parse_datetime_string(value): try: return parse_iso_datetime_to_utc(value) except Exception: raise FieldValueError(public_message=( u'"{}" is not a valid date + ' u'time specification'.format(ascii_str(value))))
def ascii_only_to_unicode_stripped(val): if isinstance(val, unicode): try: val.encode('ascii', 'strict') # just to check against encoding errors except UnicodeEncodeError as exc: raise FieldValueError( public_message=invalid_field_template_msg.format(value=val, exc=exc)) else: assert isinstance(val, str) try: val = val.decode('ascii', 'strict') except UnicodeDecodeError as exc: raise FieldValueError( public_message=invalid_field_template_msg.format(value=val, exc=exc)) assert isinstance(val, unicode) return val.strip()
def _validate_value(self, value): super(UnicodeEnumField, self)._validate_value(value) if value not in self.enum_values: raise FieldValueError( public_message=(u'"{}" is not one of: {}'.format( ascii_str(value), u', '.join(u'"{}"'.format(v) for v in self.enum_values))))
def validate_time_hour_minute_only(val): hour_minute_format = '%H:%M' try: datetime.datetime.strptime(val, hour_minute_format) except (TypeError, ValueError) as exc: raise FieldValueError(public_message=invalid_field_template_msg.format(value=val, exc=exc)) return val
def _iter_clean_param_items(self, params, keys): error_info_seq = [] for key in keys: assert key in self._all_param_fields assert key in params field = self._all_param_fields[key] param_values = params[key] assert param_values and type(param_values) is list assert hasattr(field, 'single_param') if field.single_param and len(param_values) > 1: error_info_seq.append( (key, param_values, FieldValueError(public_message=( u'Multiple values for a single-value-only field.')))) else: cleaned_values = [] for value in param_values: try: cleaned_val = field.clean_param_value(value) except Exception as exc: error_info_seq.append((key, value, exc)) else: cleaned_values.append(cleaned_val) if cleaned_values: yield key, cleaned_values if error_info_seq: raise ParamValueCleaningError(error_info_seq)
def clean_param_value(self, value): """ The input `value` should be such a (:class:`str` or :class:`unicode`) string that ``value.lower()`` is equal to one of: * ``""`` or ``"yes"``, or ``"y"``, or ``"true"``, or ``"t"``, or ``"1"``, or ``"on"`` -- then the resultant cleaned value will be :obj:`True`; * ``"no"`` or ``"n"``, or ``"false"``, or ``"f"``, or ``"0"``, or ``"off"`` -- then the resultant cleaned value will be :obj:`False`; Note that when an empty string is given the resultant cleaned value will be :obj:`True` (!); thanks to this rule, a flag can be set by specifying the apropriate URL query parameter with no value (i.e., by using just its name). Returns: a :class:`bool` object (:obj:`True` or :obj:`False`). """ value = super(FlagField, self).clean_param_value(value) if not value: return True value = value.lower() try: value = string_to_bool(value) except ValueError: raise FieldValueError( public_message=(string_to_bool.PUBLIC_MESSAGE_PATTERN.format( ascii_str(value)))) return value
def _fix_value(self, value): value = super(IPv6Field, self)._fix_value(value) try: ipv6_obj = ipaddr.IPv6Address(value) except Exception: raise FieldValueError(public_message=( self.error_msg_template.format(ascii_str(value)))) return ipv6_obj
def _fix_value(self, value): value = super(DomainNameSubstringField, self)._fix_value(value) try: ascii_value = value.encode('idna') except ValueError: raise FieldValueError( public_message=(u'"{}" could not be encoded using the ' u'IDNA encoding'.format(ascii_str(value)))) return unicode(ascii_value.lower())
def _fix_value(self, value): value = super(IPv6NetField, self)._fix_value(value) try: if '/' not in value: raise ValueError ipv6_network_obj = ipaddr.IPv6Network(value) except Exception: raise FieldValueError(public_message=( self.error_msg_template.format(ascii_str(value)))) return ipv6_network_obj
def clean_result_value(self, value): if not isinstance(value, basestring): try: ip, net = value value = '{}/{}'.format(ip, net) except (ValueError, TypeError): raise FieldValueError(public_message=( self.error_msg_template.format(ascii_str(value)))) # returning a unicode string return super(IPv4NetField, self).clean_result_value(value)
def _validate_value(self, value): super(HexDigestField, self)._validate_value(value) try: value.decode('hex') if len(value) != self.num_of_characters: raise ValueError except (TypeError, ValueError): raise FieldValueError( public_message=(u'"{}" is not a valid {} hash'.format( ascii_str(value), self.hash_algo_descr)))
def _clean_value(self, value): try: value = self._coerce_value(value) self._check_range(value) except FieldValueError: if self.error_msg_template is None: raise raise FieldValueError(public_message=( self.error_msg_template.format(ascii_str(value)))) return value
def _fix_value(self, value): if isinstance(value, str): try: value = value.decode(self.encoding, self.decode_error_handling) except UnicodeError: raise FieldValueError(public_message=( u'"{}" cannot be decoded with encoding "{}"'.format( ascii_str(value), self.encoding))) assert isinstance(value, unicode) return value
def clean_result_value(self, value): str = unicode #3-- if not isinstance(value, (str, bytes, bytearray)): try: ip, net = value value = '{}/{}'.format(as_unicode(ip), as_unicode(net)) except (ValueError, TypeError): raise FieldValueError(public_message=( self.error_msg_template.format(ascii_str(value)))) # returning a str return super(IPv4NetField, self).clean_result_value(value)
def _fix_value(self, value): if isinstance(value, (bytes, bytearray)): try: value = value.decode(self.encoding, self.decode_error_handling) except UnicodeError: raise FieldValueError(public_message=( u'"{}" cannot be decoded with encoding "{}"'.format( ascii_str(value), self.encoding))) assert isinstance(value, unicode) #3: `unicode`->`str` if self.auto_strip: value = value.strip() return value
def _coerce_value(self, value): try: coerced_value = self._do_coerce(value) # e.g. float is OK *only* if it is an integer number (such as 42.0) if not isinstance(value, basestring) and coerced_value != value: raise ValueError except (TypeError, ValueError): raise FieldValueError( public_message=(u'"{}" cannot be interpreted as an ' u'integer number'.format(ascii_str(value)))) assert isinstance(coerced_value, (int, long)) # long if > sys.maxint return coerced_value
def _fix_value(self, value): value = super(IPv6Field, self)._fix_value(value) try: _, _, last_segment = value.rpartition(':') if '.' in last_segment and not IPv4_STRICT_DECIMAL_REGEX.search( last_segment): raise ValueError('{!r} is not a valid IPv4-like suffix'.format( last_segment)) ipv6_obj = ipaddress.IPv6Address(value) except Exception: raise FieldValueError(public_message=( self.error_msg_template.format(ascii_str(value)))) return ipv6_obj
def _coerce_value(self, value): try: coerced_value = self._do_coerce(value) # e.g. float is OK *only* if it is an integer number (such as 42.0) str = unicode #3-- if not isinstance( value, (str, bytes, bytearray)) and coerced_value != value: raise ValueError except (TypeError, ValueError): raise FieldValueError( public_message=(u'"{}" cannot be interpreted as an ' u'integer number'.format(ascii_str(value)))) assert isinstance(coerced_value, (int, long)) #3: `long`-- return coerced_value
def _validate_value(self, value): super(HexDigestField, self)._validate_value(value) try: if hasattr(bytes, 'fromhex'): #3-- bytes.fromhex(value) #3: keep just `bytes.fromhex(value)` else: value.decode('hex') #3-- if len(value) != self.num_of_characters: raise ValueError('expected length: {!r} (got: {!r})'.format( self.num_of_characters, len(value))) except (TypeError, ValueError): raise FieldValueError( public_message=(u'"{}" is not a valid {} hash'.format( ascii_str(value), self.hash_algo_descr)))
def _urlsafe_b64decode(self, value): value = value.rstrip( '\r\n') # some encoders like to append a newline... try: # `base64.urlsafe_b64decode()` just ignores illegal # characters *but* we want to be *more strict* if not self._URLSAFE_B64_VALID_CHARACTERS.issuperset(value): raise ValueError value = base64.urlsafe_b64decode(value) except ValueError: # (^ also `binascii.Error` may be raised but # it is a subclass of `ValueError` anyway) raise FieldValueError(public_message=( '"{}" is not a valid URL-safe-Base64-encoded string ' '[see: RFC 4648, section 5]'.format(ascii_str(value)))) return value
def _urlsafe_b64decode(self, value): value = value.rstrip('\r\n') # some encoders like to append a newline... try: # `base64.urlsafe_b64decode()` just ignores illegal # characters *but* we want to be *more strict* if not self._URLSAFE_B64_VALID_CHARACTERS.issuperset(value): raise ValueError # `base64.urlsafe_b64decode()` (contrary to `base64.standard_b64decode()`) # does *not* accept unicode strings (even not pure-ASCII ones) :-/ value = string_as_bytes(value) value = base64.urlsafe_b64decode(value) except (ValueError, TypeError): # (TypeError is raised on incorrect Base64 padding) raise FieldValueError(public_message=( '"{}" is not a valid URL-safe-Base64-encoded string ' '[see: RFC 4648, section 5]'.format(ascii_str(value)))) return value
def clean_result_value(self, value): str = unicode #3-- if not isinstance(value, (str, bytes, bytearray)): try: ipv6_raw, prefixlen_raw = value value = '{}/{}'.format(as_unicode(ipv6_raw), as_unicode(prefixlen_raw)) except (ValueError, TypeError): raise FieldValueError(public_message=( self.error_msg_template.format(ascii_str(value)))) ipv6_obj, prefixlen = super(IPv6NetField, self).clean_result_value(value) assert isinstance(ipv6_obj, ipaddress.IPv6Address) ipv6 = str(ipv6_obj.compressed) #3: `str(`-- `)`-- assert isinstance(ipv6, str) assert isinstance(prefixlen, int) and 0 <= prefixlen <= 128, prefixlen # returning a str return str('{}/{}'.format(ipv6, prefixlen)) #3: `str(`-- `)`--
def _iter_clean_param_items(self, params, keys): error_info_seq = [] for key in keys: assert key in self._all_param_fields assert key in params field = self._all_param_fields[key] param_values = params[key] if not (isinstance(param_values, list) and all( isinstance(val, (str, unicode)) #3: `unicode`--, just `str` for val in param_values)): safe_repr_func = ( (lambda obj: ascii_str(object.__repr__(obj))) if field.sensitive else repr) #3: `repr`->`ascii` raise TypeError('{}={}, not being a list of str'.format( key, safe_repr_func(param_values))) assert param_values assert hasattr(field, 'single_param') if field.single_param and len(param_values) > 1: safe_values = list( self._get_value_or_safe_replacement(field, value) for value in param_values) error_info_seq.append( (key, safe_values, FieldValueError(public_message=( u'Multiple values for a single-value-only field.')))) else: cleaned_values = [] for value in param_values: try: cleaned_val = field.clean_param_value(value) except Exception as exc: error_info_seq.append(( key, self._get_value_or_safe_replacement(field, value), self._get_safe_exc(field, exc), )) else: cleaned_values.append(cleaned_val) if cleaned_values: yield key, cleaned_values if error_info_seq: raise ParamValueCleaningError(error_info_seq)
def _fix_value(self, value): value = super(IPv6NetField, self)._fix_value(value) try: ipv6_str, prefixlen_str = value.split('/') _, _, last_segment = ipv6_str.rpartition(':') if '.' in last_segment and not IPv4_STRICT_DECIMAL_REGEX.search( last_segment): raise ValueError('{!r} is not a valid IPv4-like suffix ' 'of the address part'.format(last_segment)) ipv6_obj = ipaddress.IPv6Address(ipv6_str) prefixlen = int(prefixlen_str) if str(prefixlen) != prefixlen_str: raise ValueError('{!r} != {!r}'.format(str(prefixlen), prefixlen_str)) if not 0 <= prefixlen <= 128: raise ValueError('{!r} not in range 0..128'.format(prefixlen)) except Exception: raise FieldValueError(public_message=( self.error_msg_template.format(ascii_str(value)))) return ipv6_obj, prefixlen
def _get_safe_exc(self, field, exc): if field.sensitive and not getattr(exc, 'safe_for_sensitive', False): return FieldValueError( public_message=field.default_error_msg_if_sensitive) return exc
def _validate_value(self, value): if self.disallow_empty and not value: raise FieldValueError(public_message=u'The value is empty')
def _validate_value(self, value): super(UnicodeRegexField, self)._validate_value(value) if self.regex.search(value) is None: raise FieldValueError(public_message=( self.error_msg_template.format(ascii_str(value))))