def __init__(self,
extra=None,
only=(),
exclude=(),
prefix='',
strict=None,
many=False,
context=None,
load_only=(),
dump_only=(),
partial=False):
# copy declared fields from metaclass
self.declared_fields = copy.deepcopy(self._declared_fields)
self.many = many
self.only = only
self.exclude = exclude
self.prefix = prefix
self.strict = strict if strict is not None else self.opts.strict
self.ordered = self.opts.ordered
self.load_only = set(load_only) or set(self.opts.load_only)
self.dump_only = set(dump_only) or set(self.opts.dump_only)
self.partial = partial
#: Dictionary mapping field_names -> :class:`Field` objects
self.fields = self.dict_class()
#: Callable marshalling object
self._marshal = marshalling.Marshaller(prefix=self.prefix)
#: Callable unmarshalling object
self._unmarshal = marshalling.Unmarshaller()
if extra:
warnings.warn(
'The `extra` argument is deprecated. Use a post_dump '
'method to add additional data instead.', DeprecationWarning)
self.extra = extra
self.context = context or {}
self._normalize_nested_options()
self._types_seen = set()
self._update_fields(many=many)
def _do_load(
self,
data,
many=None,
partial=None,
unknown=None,
postprocess=True,
):
"""Deserialize `data`, returning the deserialized result.
:param data: The data to deserialize.
:param bool many: Whether to deserialize `data` as a collection. If `None`, the
value for `self.many` is used.
:param bool|tuple partial: Whether to validate required fields. If its value is an iterable,
only fields listed in that iterable will be ignored will be allowed missing.
If `True`, all fields will be allowed missing.
If `None`, the value for `self.partial` is used.
:param unknown: Whether to exclude, include, or raise an error for unknown
fields in the data. Use `EXCLUDE`, `INCLUDE` or `RAISE`.
If `None`, the value for `self.unknown` is used.
:param bool postprocess: Whether to run post_load methods..
:return: A dict of deserialized data
:rtype: dict
"""
# Callable unmarshalling object
unmarshal = marshalling.Unmarshaller()
errors = {}
many = self.many if many is None else bool(many)
unknown = unknown or self.unknown
if partial is None:
partial = self.partial
if self._has_processors(PRE_LOAD):
try:
processed_data = self._invoke_load_processors(
PRE_LOAD,
data,
many,
original_data=data,
)
except ValidationError as err:
errors = err.normalized_messages()
result = None
else:
processed_data = data
if not errors:
result = unmarshal(
processed_data,
self.fields,
many=many,
partial=partial,
unknown=unknown,
dict_class=self.dict_class,
index_errors=self.opts.index_errors,
)
self._invoke_field_validators(unmarshal, data=result, many=many)
errors = unmarshal.errors
# Run schema-level validation.
if self._has_processors(VALIDATES_SCHEMA):
field_errors = bool(errors)
self._invoke_schema_validators(
unmarshal,
pass_many=True,
data=result,
original_data=data,
many=many,
field_errors=field_errors,
)
self._invoke_schema_validators(
unmarshal,
pass_many=False,
data=result,
original_data=data,
many=many,
field_errors=field_errors,
)
# Run post processors
if not errors and postprocess and self._has_processors(POST_LOAD):
try:
result = self._invoke_load_processors(
POST_LOAD,
result,
many,
original_data=data,
)
except ValidationError as err:
errors = err.normalized_messages()
if errors:
exc = ValidationError(errors,
field_names=unmarshal.error_field_names,
data=data,
valid_data=result,
**unmarshal.error_kwargs)
self.handle_error(exc, data)
raise exc
return result
def _do_load(self, data, many=None, partial=None, postprocess=True):
"""Deserialize `data`, returning the deserialized result and a dictonary of
validation errors.
:param data: The data to deserialize.
:param bool many: Whether to deserialize `data` as a collection. If `None`, the
value for `self.many` is used.
:param bool|tuple partial: Whether to validate required fields. If its value is an iterable,
only fields listed in that iterable will be ignored will be allowed missing.
If `True`, all fields will be allowed missing.
If `None`, the value for `self.partial` is used.
:param bool postprocess: Whether to run post_load methods..
:return: A tuple of the form (`data`, `errors`)
"""
# Callable unmarshalling object
unmarshal = marshalling.Unmarshaller()
errors = {}
many = self.many if many is None else bool(many)
if partial is None:
partial = self.partial
try:
processed_data = self._invoke_load_processors(
PRE_LOAD,
data,
many,
original_data=data)
except ValidationError as err:
errors = err.normalized_messages()
result = None
if not errors:
try:
result = unmarshal(
processed_data,
self.fields,
many=many,
partial=partial,
dict_class=self.dict_class,
index_errors=self.opts.index_errors,
)
except ValidationError as error:
result = error.data
self._invoke_field_validators(unmarshal, data=result, many=many)
errors = unmarshal.errors
field_errors = bool(errors)
# Run schema-level migration
try:
self._invoke_validators(unmarshal, pass_many=True, data=result, original_data=data,
many=many, field_errors=field_errors)
except ValidationError as err:
errors.update(err.messages)
try:
self._invoke_validators(unmarshal, pass_many=False, data=result, original_data=data,
many=many, field_errors=field_errors)
except ValidationError as err:
errors.update(err.messages)
# Run post processors
if not errors and postprocess:
try:
result = self._invoke_load_processors(
POST_LOAD,
result,
many,
original_data=data)
except ValidationError as err:
errors = err.normalized_messages()
if errors:
# TODO: Remove self.__error_handler__ in a later release
if self.__error_handler__ and callable(self.__error_handler__):
self.__error_handler__(errors, data)
exc = ValidationError(
errors,
field_names=unmarshal.error_field_names,
fields=unmarshal.error_fields,
data=data,
**unmarshal.error_kwargs
)
self.handle_error(exc, data)
if self.strict:
raise exc
return result, errors
def _do_load( # noqa:C901
self, data, many=None, partial=None, unknown=None,
postprocess=True,
):
errors = {}
result = None
processed_data = None
many = self.many if many is None else bool(many)
unknown = unknown or self.unknown
if partial is None:
partial = self.partial
if self._has_processors(PRE_LOAD):
try:
processed_data = self._invoke_load_processors(
PRE_LOAD,
data,
many,
original_data=data,
)
except ValidationError as err:
errors = err.normalized_messages()
else:
processed_data = data
unmarshaller = marshalling.Unmarshaller()
if not errors:
result = unmarshaller.deserialize(
processed_data,
self._fields,
many=False,
partial=partial,
unknown=unknown,
dict_class=self.dict_class,
index_errors=self.opts.index_errors,
)
self._invoke_field_validators(unmarshaller, data=result, many=False)
if self._has_processors(VALIDATES_SCHEMA):
field_errors = bool(unmarshaller.errors)
self._invoke_schema_validators(
unmarshaller,
pass_many=True,
data=result,
original_data=data,
many=many,
field_errors=field_errors,
)
self._invoke_schema_validators(
unmarshaller,
pass_many=False,
data=result,
original_data=data,
many=many,
field_errors=field_errors,
)
errors = unmarshaller.errors
if not errors and postprocess and self._has_processors(POST_LOAD):
try:
result = self._invoke_load_processors(
POST_LOAD,
result,
many,
original_data=data,
)
except ValidationError as err:
errors = err.normalized_messages()
if errors:
error_field_names = getattr(unmarshaller, 'error_field_names', [])
exc = ValidationError(
errors,
field_names=error_field_names,
data=data,
valid_data=result,
**unmarshaller.error_kwargs
)
self.handle_error(exc, data)
raise exc
return result