def test_is_keyed_tuple():
Point = namedtuple('Point', ['x', 'y'])
p = Point(24, 42)
assert utils.is_keyed_tuple(p) is True
t = (24, 42)
assert utils.is_keyed_tuple(t) is False
d = {'x': 42, 'y': 24}
assert utils.is_keyed_tuple(d) is False
s = 'xy'
assert utils.is_keyed_tuple(s) is False
l = [24, 42]
assert utils.is_keyed_tuple(l) is False
def test_is_keyed_tuple():
Point = namedtuple("Point", ["x", "y"])
p = Point(24, 42)
assert utils.is_keyed_tuple(p) is True
t = (24, 42)
assert utils.is_keyed_tuple(t) is False
d = {"x": 42, "y": 24}
assert utils.is_keyed_tuple(d) is False
s = "xy"
assert utils.is_keyed_tuple(s) is False
lst = [24, 42]
assert utils.is_keyed_tuple(lst) is False
def test_is_keyed_tuple():
Point = namedtuple('Point', ['x', 'y'])
p = Point(24, 42)
assert utils.is_keyed_tuple(p) is True
t = (24, 42)
assert utils.is_keyed_tuple(t) is False
d = {'x': 42, 'y': 24}
assert utils.is_keyed_tuple(d) is False
s = 'xy'
assert utils.is_keyed_tuple(s) is False
lst = [24, 42]
assert utils.is_keyed_tuple(lst) is False
def dump(self, obj):
"""Serialize an object to native Python data types according to this
Schema's fields.
:param obj: The object to serialize.
:return: A tuple of the form (``data``, ``errors``)
:rtype: `MarshalResult`, a `collections.namedtuple`
.. versionadded:: 1.0.0
"""
if not self.many and utils.is_collection(obj) and not utils.is_keyed_tuple(obj):
warnings.warn('Implicit collection handling is deprecated. Set '
'many=True to serialize a collection.',
category=DeprecationWarning)
if isinstance(obj, types.GeneratorType):
obj = list(obj)
self._update_fields(obj)
preresult = self._marshal(
obj,
self.fields,
many=self.many,
strict=self.strict
)
result = self._postprocess(preresult, obj=obj)
errors = self._marshal.errors
return MarshalResult(result, errors)
def dump(self, obj, many=None, update_fields=True, **kwargs):
"""Serialize an object to native Python data types according to this
Schema's fields.
:param obj: The object to serialize.
:param bool many: Whether to serialize `obj` as a collection. If `None`, the value
for `self.many` is used.
:param bool update_fields: Whether to update the schema's field classes. Typically
set to `True`, but may be `False` when serializing a homogenous collection.
This parameter is used by `fields.Nested` to avoid multiple updates.
:return: A tuple of the form (``data``, ``errors``)
:rtype: `MarshalResult`, a `collections.namedtuple`
.. versionadded:: 1.0.0
"""
many = self.many if many is None else bool(many)
if not many and utils.is_collection(
obj) and not utils.is_keyed_tuple(obj):
warnings.warn(
'Implicit collection handling is deprecated. Set '
'many=True to serialize a collection.',
category=DeprecationWarning)
if isinstance(obj, types.GeneratorType):
obj = list(obj)
processed_obj = self._invoke_dump_processors(PRE_DUMP,
obj,
many,
original_data=obj)
if update_fields:
self._update_fields(processed_obj, many=many)
try:
preresult = self._marshal(
processed_obj,
self.fields,
many=many,
# TODO: Remove self.__accessor__ in a later release
accessor=self.get_attribute or self.__accessor__,
dict_class=self.dict_class,
index_errors=self.opts.index_errors,
**kwargs)
except ValidationError as error:
errors = self._marshal.errors
preresult = error.data
if self.strict:
raise error
else:
errors = {}
result = self._postprocess(preresult, many, obj=obj)
result = self._invoke_dump_processors(POST_DUMP,
result,
many,
original_data=obj)
return MarshalResult(result, errors)
def dump(self, obj, many=None, update_fields=True, **kwargs):
"""Serialize an object to native Python data types according to this
Schema's fields.
:param obj: The object to serialize.
:param bool many: Whether to serialize `obj` as a collection. If `None`, the value
for `self.many` is used.
:param bool update_fields: Whether to update the schema's field classes. Typically
set to `True`, but may be `False` when serializing a homogenous collection.
This parameter is used by `fields.Nested` to avoid multiple updates.
:return: A tuple of the form (``data``, ``errors``)
:rtype: `MarshalResult`, a `collections.namedtuple`
.. versionadded:: 1.0.0
"""
many = self.many if many is None else bool(many)
if not many and utils.is_collection(obj) and not utils.is_keyed_tuple(obj):
warnings.warn('Implicit collection handling is deprecated. Set '
'many=True to serialize a collection.',
category=DeprecationWarning)
if many and utils.is_iterable_but_not_string(obj):
obj = list(obj)
processed_obj = self._invoke_dump_processors(PRE_DUMP, obj, many, original_data=obj)
if update_fields:
self._update_fields(processed_obj, many=many)
try:
preresult = self._marshal(
processed_obj,
self.fields,
many=many,
# TODO: Remove self.__accessor__ in a later release
accessor=self.get_attribute or self.__accessor__,
dict_class=self.dict_class,
index_errors=self.opts.index_errors,
**kwargs
)
except ValidationError as error:
errors = self._marshal.errors
preresult = error.data
if self.strict:
raise error
else:
errors = {}
result = self._postprocess(preresult, many, obj=obj)
result = self._invoke_dump_processors(POST_DUMP, result, many, original_data=obj)
return MarshalResult(result, errors)
def dump(self, obj, many=None, update_fields=True, **kwargs):
"""Serialize an object to native Python data types according to this
Schema's fields.
:param obj: The object to serialize.
:param bool many: Whether to serialize `obj` as a collection. If `None`, the value
for `self.many` is used.
:param bool update_fields: Whether to update the schema's field classes. Typically
set to `True`, but may be `False` when serializing a homogenous collection.
This parameter is used by `fields.Nested` to avoid multiple updates.
:return: A tuple of the form (``data``, ``errors``)
:rtype: `MarshalResult`, a `collections.namedtuple`
.. versionadded:: 1.0.0
"""
many = self.many if many is None else bool(many)
if not many and utils.is_collection(obj) and not utils.is_keyed_tuple(obj):
warnings.warn('Implicit collection handling is deprecated. Set '
'many=True to serialize a collection.',
category=DeprecationWarning)
if isinstance(obj, types.GeneratorType):
obj = list(obj)
if update_fields:
self._update_fields(obj, many=many)
preresult = self._marshal(
obj,
self.fields,
many=many,
strict=self.strict,
skip_missing=self.skip_missing,
accessor=self.__accessor__,
dict_class=self.dict_class,
**kwargs
)
result = self._postprocess(preresult, many, obj=obj)
errors = self._marshal.errors
return MarshalResult(result, errors)
def dump(self, obj, many=None, update_fields=True, **kwargs):
"""Serialize an object to native Python data types according to this
Schema's fields.
:param obj: The object to serialize.
:param bool many: Whether to serialize `obj` as a collection. If `None`, the value
for `self.many` is used.
:param bool update_fields: Whether to update the schema's field classes. Typically
set to `True`, but may be `False` when serializing a homogenous collection.
This parameter is used by `fields.Nested` to avoid multiple updates.
:return: A tuple of the form (``data``, ``errors``)
:rtype: `MarshalResult`, a `collections.namedtuple`
.. versionadded:: 1.0.0
"""
many = self.many if many is None else bool(many)
if not many and utils.is_collection(
obj) and not utils.is_keyed_tuple(obj):
warnings.warn(
'Implicit collection handling is deprecated. Set '
'many=True to serialize a collection.',
category=DeprecationWarning)
if isinstance(obj, types.GeneratorType):
obj = list(obj)
if update_fields:
self._update_fields(obj, many=many)
preresult = self._marshal(obj,
self.fields,
many=many,
strict=self.strict,
skip_missing=self.skip_missing,
accessor=self.__accessor__,
dict_class=self.dict_class,
**kwargs)
result = self._postprocess(preresult, many, obj=obj)
errors = self._marshal.errors
return MarshalResult(result, errors)
def dump(self, obj, many=None, update_fields=True, **kwargs):
"""Serialize an object to native Python data types according to this
Schema's fields.
:param obj: The object to serialize.
:param bool many: Whether to serialize `obj` as a collection. If `None`, the value
for `self.many` is used.
:param bool update_fields: Whether to update the schema's field classes. Typically
set to `True`, but may be `False` when serializing a homogenous collection.
This parameter is used by `fields.Nested` to avoid multiple updates.
:return: A tuple of the form (``data``, ``errors``)
:rtype: `MarshalResult`, a `collections.namedtuple`
.. versionadded:: 1.0.0
"""
# Callable marshalling object
marshal = marshalling.Marshaller(prefix=self.prefix)
errors = {}
many = self.many if many is None else bool(many)
if not many and utils.is_collection(obj) and not utils.is_keyed_tuple(obj):
warnings.warn('Implicit collection handling is deprecated. Set '
'many=True to serialize a collection.',
category=DeprecationWarning)
if many and utils.is_iterable_but_not_string(obj):
obj = list(obj)
if self._has_processors:
try:
processed_obj = self._invoke_dump_processors(
PRE_DUMP,
obj,
many,
original_data=obj)
except ValidationError as error:
errors = error.normalized_messages()
result = None
else:
processed_obj = obj
if not errors:
if update_fields:
obj_type = type(processed_obj)
if obj_type not in self._types_seen:
self._update_fields(processed_obj, many=many)
if not isinstance(processed_obj, Mapping):
self._types_seen.add(obj_type)
try:
preresult = marshal(
processed_obj,
self.fields,
many=many,
# TODO: Remove self.__accessor__ in a later release
accessor=self.get_attribute or self.__accessor__,
dict_class=self.dict_class,
index_errors=self.opts.index_errors,
**kwargs
)
except ValidationError as error:
errors = marshal.errors
preresult = error.data
result = self._postprocess(preresult, many, obj=obj)
if not errors and self._has_processors:
try:
result = self._invoke_dump_processors(
POST_DUMP,
result,
many,
original_data=obj)
except ValidationError as error:
errors = error.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, obj)
exc = ValidationError(
errors,
field_names=marshal.error_field_names,
fields=marshal.error_fields,
data=obj,
**marshal.error_kwargs
)
self.handle_error(exc, obj)
if self.strict:
raise exc
return MarshalResult(result, errors)
