def _deserialize(self, value, attr, data, **kwargs):
""" deserialize comma separated string to list of strings
"""
# empty
if not value:
return []
# handle list
if isinstance(value, list):
try:
value = [ensure_text_type(item) for item in value]
except UnicodeDecodeError as exc:
raise self.make_error("invalid_utf8") from exc
# handle text
else:
if not isinstance(value, (str, bytes)):
raise self.make_error("invalid")
try:
value = ensure_text_type(value)
except UnicodeDecodeError as exc:
raise self.make_error("invalid_utf8") from exc
else:
value = filter(bool, (item.strip() for item in value.split(',')))
return list(value)
def _deserialize(self, value, attr, data):
if not isinstance(value, basestring):
self.fail('invalid')
try:
return utils.ensure_text_type(value)
except UnicodeDecodeError:
self.fail('invalid_utf8')
def _deserialize(self, value, attr, data,
**kwargs) -> [Representation, None]:
if not isinstance(value, (str, bytes)):
raise self.make_error("invalid")
try:
value = utils.ensure_text_type(value)
except UnicodeDecodeError as error:
raise self.make_error("invalid_utf8") from error
value = parse_options_header(value)
command, _options = value
if not command.startswith(RETURN_PREFIX):
return None
representation = command[len(RETURN_PREFIX):]
options = {}
for k, v in _options.items():
if k in ('include', 'exclude', 'select'):
options[k] = set((v or '').strip().split())
else:
options[k] = (v or '').strip()
return Representation(representation,
include=options.pop('include', None),
exclude=options.pop('exclude', None),
select=options.pop('select', None),
options=options)
def _deserialize(self, value, attr, data, **kwargs):
""" deserialize a string or list of strings to dkim key data
with verification
"""
# convert list to str
if isinstance(value, list):
try:
value = ''.join(ensure_text_type(item)
for item in value).strip()
except UnicodeDecodeError as exc:
raise self.make_error("invalid_utf8") from exc
# only text is allowed
else:
if not isinstance(value, (str, bytes)):
raise self.make_error("invalid")
try:
value = ensure_text_type(value).strip()
except UnicodeDecodeError as exc:
raise self.make_error("invalid_utf8") from exc
# generate new key?
if value.lower() == '-generate-':
return dkim.gen_key()
# no key?
if not value:
return None
# remember part of value for ValidationError
bad_key = value
# strip header and footer, clean whitespace and wrap to 64 characters
try:
if value.startswith('-----BEGIN '):
end = value.index('-----', 11) + 5
header = value[:end]
value = value[end:]
else:
header = '-----BEGIN PRIVATE KEY-----'
if (pos := value.find('-----END ')) >= 0:
end = value.index('-----', pos + 9) + 5
footer = value[pos:end]
value = value[:pos]
else:
def _deserialize(self, value, attr, data):
try:
value = str(value)
except:
pass
if not isinstance(value, basestring):
self.fail('invalid')
return utils.ensure_text_type(value)
def _deserialize(self, value, attr, data,
**kwargs) -> [Representation, None]:
if not isinstance(value, (str, bytes)):
raise self.make_error("invalid")
try:
value = utils.ensure_text_type(value)
except UnicodeDecodeError as error:
raise self.make_error("invalid_utf8") from error
value = [x.strip() for x in re.split(r'[ ,]', value)]
return value
def _deserialize(self, value, attr, data, **kwargs):
if value in (True, 'true', 'True'):
return True
if value in (False, 'false', 'False'):
return False
try:
return utils.ensure_text_type(value)
except UnicodeDecodeError:
self.make_error('invalid_utf8')
def _deserialize(
self, value, attr, data, **kwargs
) -> typing.Optional[typing.Union[ipaddress.IPv4Interface,
ipaddress.IPv6Interface]]:
if value is None:
return None
try:
logger.info(f"deserialize : {value}")
return (self.DESERIALIZATION_CLASS
or ipaddress.ip_interface)(utils.ensure_text_type(value))
except (ValueError, TypeError) as error:
raise self.make_error("invalid_ip_interface") from error
def _deserialize(self, value, attr, data):
if value in (True, 'true', 'True'):
return True
if value in (False, 'false', 'False'):
return False
if not isinstance(value, compat.basestring):
self.fail('invalid')
try:
return utils.ensure_text_type(value)
except UnicodeDecodeError:
self.fail('invalid_utf8')
def _serialize(self, value, attr, obj):
if value is None:
return None
return utils.ensure_text_type(value)
def _deserialize(self, value, attr, data):
if not isinstance(value, basestring):
self.fail('invalid')
return utils.ensure_text_type(value)
def _serialize(self, value, attr, obj):
if value is None:
return None
return utils.ensure_text_type(value)
def _deserialize(self, value, attr, data):
if not isinstance(value, basestring):
self.fail('invalid')
return utils.ensure_text_type(value.strip())
def _deserialize(self, value):
result = utils.ensure_text_type(value)
return result
def coerce_meta_value(self, data):
meta = data.setdefault('meta', {})
for key, value in meta.iteritems():
meta[key] = ensure_text_type(value or '')
return data
def _deserialize(self, value):
if value is None:
return ''
result = utils.ensure_text_type(value)
return result
def _serialize(self, value, attr, obj):
return utils.ensure_text_type(value)
