def to_native(self, value, context=None):
if isinstance(value, datetime):
return value
try:
return parse_date(value, default_timezone=TZ)
except ValueError:
raise ConversionError(self.messages["parse"].format(value))
except OverflowError as e:
raise ConversionError(str(e))
def to_native(self, value, context=None):
if isinstance(value, Duration) or isinstance(value, timedelta):
return value
try:
return parse_duration(value)
except TypeError:
raise ConversionError(self.messages["parse"].format(value))
except ISO8601Error as e:
raise ConversionError(str(e))
def to_native(self, value, context=None):
try:
value = Decimal(value).quantize(self.precision, rounding=ROUND_HALF_UP).normalize()
except (TypeError, InvalidOperation):
raise ConversionError(self.messages['number_coerce'].format(value))
if self.min_value is not None and value < self.min_value:
raise ConversionError(self.messages['number_min'].format(value))
if self.max_value is not None and self.max_value < value:
raise ConversionError(self.messages['number_max'].format(value))
return value
def to_native(self, value, context=None):
if isinstance(value, datetime):
return value
try:
date = parse_date(value, None)
if not date.tzinfo:
date = TZ.localize(date)
return date
except ParseError:
raise ConversionError(self.messages['parse'].format(value))
except OverflowError as e:
raise ConversionError(e.message)
def _force_list(self, value):
if value is None or value == EMPTY_LIST:
return []
try:
return list(value)
except Exception as e:
raise ConversionError("Invalid list")
def to_native(self, value, context=None):
if isinstance(value, datetime.datetime):
return value
for fmt in self.formats:
try:
return datetime.datetime.strptime(value, fmt)
except (ValueError, TypeError):
continue
# as last ressort, try https://stackoverflow.com/a/13182163/1029655
if (len(value) > 2 and value[-3] == ":"
and '%Y-%m-%dT%H:%M:%S.%f%z' in self.formats):
try:
return datetime.datetime.strptime(
''.join(value.rsplit(':', 1)), '%Y-%m-%dT%H:%M:%S.%f%z')
except (ValueError, TypeError):
pass
if self.formats == self.DEFAULT_FORMATS:
message = self.messages['parse'].format(value)
else:
message = self.messages['parse_formats'].format(
value, ", ".join(self.formats))
raise ConversionError(message)
def to_native(self, value, context=None):
if isinstance(value, datetime):
return value
try:
return parse_date(value, TZ)
except ParseError:
raise ConversionError(self.messages['parse'].format(value))
def to_native(self, value, context=None):
if not isinstance(value, arrow.Arrow):
try:
value = arrow.get(value)
except arrow.parser.ParserError:
raise ConversionError('Could not parse %s. Should be ISO 8601.' % value)
return value
def to_native(self, value, context=None):
if not isinstance(value, bson.objectid.ObjectId):
try:
value = bson.objectid.ObjectId(unicode(value))
except bson.objectid.InvalidId:
raise ConversionError(self.messages['convert'])
return value
def to_native(self, value, context=None):
if isinstance(value, datetime.datetime):
return value
try:
return parse(value)
except:
raise ConversionError(u'Invalid timestamp {}'.format(value))
def _apply_precision(self, value):
try:
value = Decimal(value).quantize(
self.precision, rounding=ROUND_HALF_UP).normalize()
except (TypeError, InvalidOperation):
raise ConversionError(self.messages['number_coerce'].format(value))
return value
def to_native(self, value, context=None):
try:
return datetime.datetime.fromtimestamp(
float(value) / 1000000)
except TypeError:
if isinstance(value, datetime.datetime):
return value
raise ConversionError('Not a valid timestamp')
def to_native(self, value, context=None):
if not isinstance(value, VersionInfo):
try:
value = VersionInfo.parse(value)
except ValueError:
raise ConversionError('Could not parse %s as a SemVer string.' % value)
return value
def _json_try_convert(value, err, no_throw=False):
if isinstance(value, (bytes, str)):
try:
return json.loads(value)
except json.JSONDecodeError:
if not no_throw:
raise ConversionError(err)
return value
def to_native(self, value):
if _compare_reference_value(self.bool_values[0], value,
self.case_sensitive):
return True
elif _compare_reference_value(self.bool_values[1], value,
self.case_sensitive):
return False
else:
raise ConversionError('Value not recognised as a boolean')
def to_native(self, value, context=None):
if not value:
return dict()
if not isinstance(value, dict):
try:
value = json.loads(value)
except (AttributeError, TypeError, ValueError):
raise ConversionError(self.messages['convert'].format(value))
return value
def to_native(self, value):
"""Return the value as a dict, raising error if conversion to dict is not possible"""
if isinstance(value, dict):
return value
elif isinstance(value, six.string_types):
native_value = json.loads(value)
if isinstance(native_value, dict):
return native_value
else:
raise ConversionError(u'Cannot load value as a dict: {}'.format(value))
def to_native(self, value, context=None):
if value is False:
return None
if isinstance(value, int):
return [value, ""]
if isinstance(value, str):
try:
return [int(value), ""]
except ValueError:
raise ConversionError(self.messages["convert"].format(value))
if isinstance(value, list) or isinstance(value, tuple):
if len(value) != self.length:
raise ConversionError(self.messages["length"].format(
self.length))
try:
return [int(value[0]), str(value[1])]
except ValueError:
raise ConversionError(self.messages["convert"].format(value))
return value
raise ConversionError(self.messages["convert"].format(value))
def to_native(self, value, context=None):
if not isinstance(value, bson.objectid.ObjectId) or not isinstance(
value, str):
try:
value = bson.objectid.ObjectId(str(value))
except bson.objectid.InvalidId:
try:
value = value['$oid']
except KeyError:
raise ConversionError(self.messages['convert'])
return value
def resolve(self, value, context):
for field in self._types.values():
try:
new_value = field.convert(value, context)
if new_value != value: # Make sure the converted value is not different.
raise ConversionError('Values after conversion do not match.')
except ConversionError:
pass
else:
return field, new_value
return None
def to_native(self, value, context=None):
if isinstance(value, (memoryview, bytes)):
return value
if isinstance(value, str):
is_hex = all(c in string.hexdigits for c in value)
if not is_hex:
raise ConversionError(self.messages['hash_hex'])
if len(value) % 2 == 1:
value = '0' + value
return to_bin(value)
def to_native(self, value, context=None):
if isinstance(value, self.enum):
return value
try:
for member in self.enum.__members__:
if member.lower() == value.lower():
return self.enum.__members__[member]
else:
raise ValueError(self.messages['find'].format(
choices=self.enum.__members__, value=value))
except (ValueError, TypeError):
raise ConversionError(self.messages['convert'].format(value))
def to_native(self, value, context=None):
base_model = import_base_model()
if isinstance(value, base_model):
return value
if isinstance(value, dict):
if set(value.keys()) != set(('_cls', '_id')):
raise ConversionError(self.messages['bad_value'].format(
self=self, base_model=base_model))
self._cls = value['_cls']
return value['_id']
return super(GenericModelReferenceType,
self).to_native(value, context=context)
def to_native(self, value, context=None):
if not isinstance(value, ipaddress.IPv4Address):
try:
value = ipaddress.IPv4Address(value)
except ValueError as e:
raise ConversionError(e.__str__())
if value.is_multicast:
raise ConversionError(
"Cannot use a multicast (RFC 3171) IPv4 Address")
if value.is_unspecified:
raise ConversionError(
"Cannot use an unspecified (RFC 5735) IPv4 Address")
if self.allow_reserved is False and value.is_reserved:
raise ConversionError(
"Cannot use a reserved (IETF reserved) IPv4 Address")
if value.is_loopback:
raise ConversionError(
"Cannot use a loopback (RFC 3330) IPv4 Address")
if value.is_link_local:
raise ConversionError(
"Cannot use a link local (RFC 3927) IPv4 Address")
return value
def to_native(self, value, context=None):
if value is None:
return None
if not isinstance(value, unicode):
if isinstance(value, self.allow_casts):
if isinstance(value, bytes):
value = value.decode(encoding='UTF-8')
if not isinstance(value, str):
value = str(value)
# value = utf8_decode(value) #unicode(value, 'utf-8')
else:
raise ConversionError(self.messages['convert'].format(value))
return value
def to_native(self, value, context=None):
value = super(HashType, self).to_native(value, context)
if ':' not in value:
raise ValidationError(self.messages['hash_invalid'])
hash_type, hash_value = value.split(':', 1)
if hash_type not in algorithms:
raise ValidationError(self.messages['hash_invalid'])
if len(hash_value) != hash_new(hash_type).digest_size * 2:
raise ValidationError(self.messages['hash_length'])
try:
int(hash_value, 16)
except ValueError:
raise ConversionError(self.messages['hash_hex'])
return value
def test_builtin_conversion_exception(self):
with self.assertRaises(TypeError):
raise ConversionError('TypeError')
with self.assertRaises(TypeError):
raise ModelConversionError('TypeError')
def to_native(self, value):
for variant in self.enum_class:
if _compare_reference_value(variant.value, value,
self.case_sensitive):
return variant
raise ConversionError('Value not recognised as a variant of enum')
def _validate_choice(self, value):
if self.choices is not None:
if value not in self.choices:
raise ConversionError(
'Value was not in the set of allowed choices')
return value
def test_builtin_conversion_exception():
with pytest.raises(TypeError):
raise ConversionError('TypeError')
with pytest.raises(TypeError):
raise ModelConversionError('TypeError')