def as_marshmallow_schema(self,
params=None,
base_schema_cls=MaSchema,
check_unknown_fields=True,
mongo_world=False):
"""
Return a pure-marshmallow version of this schema class.
:param params: Per-field dict to pass parameters to their field creation.
:param base_schema_cls: Class the schema will inherit from (
default: :class:`marshmallow.Schema`).
:param check_unknown_fields: Unknown fields are considered as errors (default: True).
:param mongo_world: If True the schema will work against the mongo world
instead of the OO world (default: False).
"""
params = params or {}
nmspc = {
name: field.as_marshmallow_field(params=params.get(name),
mongo_world=mongo_world)
for name, field in self.fields.items()
}
name = 'Marshmallow%s' % type(self).__name__
if check_unknown_fields:
nmspc['_%s__check_unknown_fields' % name] = validates_schema(
pass_original=True)(schema_validator_check_unknown_fields)
# By default OO world returns `missing` fields as `None`,
# disable this behavior here to let marshmallow deals with it
if not mongo_world:
nmspc['get_attribute'] = schema_from_umongo_get_attribute
return type(name, (base_schema_cls, ), nmspc)
class BaseSchema(MaSchema):
"""
All schema used in umongo should inherit from this base schema
"""
__check_unknown_fields = validates_schema(
pass_original=True)(schema_validator_check_unknown_fields)
def map_to_field(self, func):
"""
Apply a function to every field in the schema
>>> def func(mongo_path, path, field):
... pass
"""
for name, field in self.fields.items():
mongo_path = field.attribute or name
func(mongo_path, name, field)
if hasattr(field, 'map_to_field'):
field.map_to_field(mongo_path, name, func)
def as_marshmallow_schema(self,
params=None,
base_schema_cls=MaSchema,
check_unknown_fields=True,
mongo_world=False):
"""
Return a pure-marshmallow version of this schema class.
:param params: Per-field dict to pass parameters to their field creation.
:param base_schema_cls: Class the schema will inherit from (
default: :class:`marshmallow.Schema`).
:param check_unknown_fields: Unknown fields are considered as errors (default: True).
:param mongo_world: If True the schema will work against the mongo world
instead of the OO world (default: False).
"""
params = params or {}
nmspc = {
name: field.as_marshmallow_field(params=params.get(name),
mongo_world=mongo_world)
for name, field in self.fields.items()
}
name = 'Marshmallow%s' % type(self).__name__
if check_unknown_fields:
nmspc['_%s__check_unknown_fields' % name] = validates_schema(
pass_original=True)(schema_validator_check_unknown_fields)
if hasattr(self, '_schema_model'):
nmspc['_schema_model'] = self._schema_model
# By default OO world returns `missing` fields as `None`,
# disable this behavior here to let marshmallow deals with it
if not mongo_world:
nmspc['get_attribute'] = schema_from_umongo_get_attribute
return type(name, (base_schema_cls, ), nmspc)
class SchemaFromUmongo(MaSchema):
"""
Custom :class:`marshmallow.Schema` subclass providing unknown fields
checking and custom get_attribute for umongo documents.
.. note: It is not mandatory to use this schema with umongo document.
This is just a helper providing usefull behaviors.
"""
__check_unknown_fields = validates_schema(pass_original=True)(
schema_validator_check_unknown_fields)
get_attribute = schema_from_umongo_get_attribute
def as_marshmallow_schema(self,
params=None,
base_schema_cls=MaSchema,
check_unknown_fields=True,
mongo_world=False,
meta=None):
"""
Return a pure-marshmallow version of this schema class.
:param params: Per-field dict to pass parameters to their field creation.
:param base_schema_cls: Class the schema will inherit from (
default: :class:`marshmallow.Schema`).
:param check_unknown_fields: Unknown fields are considered as errors (default: True).
:param mongo_world: If True the schema will work against the mongo world
instead of the OO world (default: False).
:param meta: Optional dict with attributes for the schema's Meta class.
"""
params = params or {}
# Use hashable parameters as cache dict key and dict parameters for manual comparison
cache_key = (self.__class__, base_schema_cls, check_unknown_fields,
mongo_world)
cache_modifiers = (params, meta)
if cache_key in self._marshmallow_schemas_cache:
for modifiers, ma_schema in self._marshmallow_schemas_cache[
cache_key]:
if modifiers == cache_modifiers:
return ma_schema
nmspc = {
name: field.as_marshmallow_field(
params=params.get(name),
base_schema_cls=base_schema_cls,
check_unknown_fields=check_unknown_fields,
mongo_world=mongo_world)
for name, field in self.fields.items()
}
name = 'Marshmallow%s' % type(self).__name__
if check_unknown_fields:
nmspc['_%s__check_unknown_fields' % name] = validates_schema(
pass_original=True)(schema_validator_check_unknown_fields)
# By default OO world returns `missing` fields as `None`,
# disable this behavior here to let marshmallow deal with it
if not mongo_world:
nmspc['get_attribute'] = schema_from_umongo_get_attribute
if meta:
nmspc['Meta'] = type('Meta', (base_schema_cls.Meta, ), meta)
ma_schema = type(name, (base_schema_cls, ), nmspc)
self._marshmallow_schemas_cache.setdefault(cache_key, []).append(
(cache_modifiers, ma_schema))
return ma_schema
class CheckUnknownSchema(marshmallow.Schema):
__check_unknown_fields = marshmallow.validates_schema(
pass_original=True)(schema_validator_check_unknown_fields)
a = marshmallow.fields.Int()
