class WorkflowMeta(MappingSchema):
"""Data structure to define a workflow (finite state machine)."""
initial_state = SingleLine(missing=required)
states = SchemaNode(Mapping(unknown='preserve'),
missing=required)
transitions = SchemaNode(Mapping(unknown='preserve'),
missing=required)
def __init__(self, *args, **kwargs):
super(DefinitionSchema, self).__init__(Mapping(), *args, **kwargs)
self.add(SchemaNode(String(), name='title'))
self.add(SchemaNode(String(), name='description'))
self.add(
SchemaNode(Mapping(unknown="preserve"), name="extra",
missing=drop))
self.add(
SchemaNode(Sequence(),
SchemaNode(TypeFieldNode()),
name='fields',
validator=Length(min=1)))
def convert_types(mapping, row):
""" Translate a row of input data (e.g. from a CSV file) into the
structure understood by the dataset loader, i.e. where all
dimensions are dicts and all types have been converted.
This will validate the incoming data and emit a colander.Invalid
exception if validation was unsuccessful."""
out = {}
errors = Invalid(SchemaNode(Mapping(unknown='preserve')))
for dimension, meta in mapping.items():
meta['dimension'] = dimension
# handle AttributeDimensions, Measures and DateDimensions.
# this is clever, but possibly not always true.
if 'column' in meta and meta['type'] not in ('compound', 'geometry'):
try:
out[dimension] = _cast(row, meta, dimension)
except Invalid, i:
errors.add(i)
# handle CompoundDimensions.
else:
out[dimension] = {}
for attribute, ameta in meta.get('attributes', {}).items():
try:
out[dimension][attribute] = \
_cast(row, ameta, dimension + '.' +
attribute)
except Invalid, i:
errors.add(i)
def definition(cls, **kwargs):
schema = SchemaNode(Mapping(unknown="preserve"))
schema.add(SchemaNode(String(), name='label', missing=u''))
schema.add(
SchemaNode(String(), name='type', validator=OneOf(["annotation"])))
return schema
def definition(cls):
schema = SchemaNode(Mapping())
schema.add(SchemaNode(String(), name='name'))
schema.add(SchemaNode(String(), name='description'))
schema.add(
SchemaNode(String(), name='type', validator=OneOf(types.names)))
return schema
def __init__(self, class_, includes=None, excludes=None, overrides=None, unknown='ignore', nested=False, type_overrides=None, relationship_overrides=None, automatic_relationships=False, **kw):
"""
:param includes:
:param overrides:
:param unknown:
:param type_overrides: callable(name, column, column_type)
:param automatic_relationships: Only follow relationships if they are on include list
:param kw:
:return:
"""
assert type_overrides, "Always provide type_overrides, otherwise this crap doesn't work when these nodes get nested"
self.inspector = inspect(class_)
kwargs = kw.copy()
# Obtain configuration specific from the mapped class
kwargs.update(getattr(self.inspector.class_, self.ca_class_key, {}))
unknown = kwargs.pop('unknown', unknown)
# The default type of this SchemaNode is Mapping.
super(SQLAlchemySchemaNode, self).__init__(Mapping(unknown), **kwargs)
self.class_ = class_
self.includes = includes or {}
self.excludes = excludes or {}
self.overrides = overrides or {}
self.unknown = unknown
self.declarative_overrides = {}
self.kwargs = kwargs or {}
self.type_overrides = type_overrides
self.relationship_overrides = relationship_overrides
self.nested = nested
self.automatic_relationships = automatic_relationships
self.add_nodes(self.includes, self.excludes, self.overrides, nested)
def ballot_voting_form(ballot_voting, request):
yes_no_choices = [(True, _('Yes')), (False, _('No')), (None, _('Abstention'))]
max_points = 9 if len(ballot_voting.options) > 3 else 3
point_choices = [(i, str(i)) for i in range(max_points+1)]
schema = Schema()
for option in ballot_voting.options:
option_schema = SchemaNode(Mapping(), name=str(option.uuid), title=option.title)
option_schema.add(SchemaNode(
Boolean(),
validator=OneOf([x[0] for x in yes_no_choices]),
widget=RadioChoiceWidget(values=yes_no_choices, inline=True),
name='yes_no',
title=f'Stimmst du dem Antrag zu?'))
option_schema.add(SchemaNode(
Int(),
validator=OneOf([x[0] for x in point_choices]),
widget=RadioChoiceWidget(values=point_choices, inline=True, null_value='0'),
name='points',
title='Welche Punktzahl gibst du dem Antrag?',
missing=0))
schema.add(option_schema)
form = Form(schema, request, buttons=[Button(title=_('check'))])
return form
def test_widget_no_maker_with_default_widget_maker(self):
from deform.widget import MappingWidget
from colander import Mapping
schema = DummySchema()
schema.typ = Mapping()
field = self._makeOne(schema)
widget = field.widget
self.assertEqual(widget.__class__, MappingWidget)
def _add_captcha(geo_form_schema, schema):
schema = schema.clone()
schema.add(SchemaNode(
Mapping(),
name='captcha',
widget=RecaptchaWidget(
public_key=geo_form_schema.recaptcha_public_key,
private_key=geo_form_schema.recaptcha_private_key)))
return schema
def __init__(self):
super(DefinitionValidator, self).__init__(Mapping())
self.add(SchemaNode(String(), name='title'))
self.add(SchemaNode(String(), name='description'))
self.add(
SchemaNode(Sequence(),
SchemaNode(TypeFieldNode()),
name='fields',
validator=Length(min=1)))
def __init__(self, definition, *args, **kwargs):
kwargs.setdefault('typ', Mapping())
super(RecordSchema, self).__init__(*args, **kwargs)
definition = deepcopy(definition)
for field in definition['fields']:
field['root'] = self
fieldtype = field.pop('type')
schema = registry.validation(fieldtype, **field)
if schema:
self.add(schema)
def definition(cls, **kwargs):
schema = SchemaNode(Mapping(unknown="preserve"))
if kwargs.get('named', True):
schema.add(
SchemaNode(String(),
name='name',
validator=Regex(r'^[a-zA-Z][a-zA-Z0-9_\-]*$')))
schema.add(SchemaNode(String(), name='label', missing=u''))
schema.add(SchemaNode(String(), name='hint', missing=cls.hint))
schema.add(SchemaNode(Boolean(), name='required',
missing=cls.required))
schema.add(
SchemaNode(String(), name='type', validator=OneOf(registry.names)))
return schema
def validator_from_model(model):
validator = Schema(Mapping())
for key, column in model.__table__.columns.items():
if key in _excludes:
# skip things like ID that won't be in the body
continue
missing = colander.required
if column.nullable:
missing = colander.drop
validator.add(
SchemaNode(sqla_to_colander_type(column.type),
name=key,
missing=missing,
**sqla_kwargs(column.type)))
return CorniceSchema.from_colander(validator)
def schema_type(self):
return Mapping()
def __init__(self, *args, **kwargs):
super(PermissionsSchema, self).__init__(Mapping(unknown='preserve'),
*args, **kwargs)
class BBoxWidget(Widget):
"""
Renders a BoundingBox Widget.
**Attributes/Arguments**
template
The template name used to render the input widget. Default:
``bbox``.
readonly_template
The template name used to render the widget in read-only mode.
Default: ``readonly/bbox``.
"""
template = 'bbox'
readonly_template = 'readonly/bbox'
_pstruct_schema = SchemaNode(
Mapping(),
SchemaNode(_StrippedString(), name='minx'),
SchemaNode(_StrippedString(), name='miny'),
SchemaNode(_StrippedString(), name='maxx'),
SchemaNode(_StrippedString(), name='maxy'))
def serialize(self, field, cstruct, **kw):
if cstruct is null:
minx = '-180'
miny = '-90'
maxx = '180'
maxy = '90'
else:
minx, miny, maxx, maxy = cstruct.split(',', 3)
kw.setdefault('minx', minx)
kw.setdefault('miny', miny)
kw.setdefault('maxx', maxx)
kw.setdefault('maxy', maxy)
# readonly = kw.get('readonly', self.readonly)
# TODO: add readonly template
readonly = False
template = readonly and self.readonly_template or self.template
values = self.get_template_values(field, cstruct, kw)
return field.renderer(template, **values)
def deserialize(self, field, pstruct):
if pstruct is null:
return null
else:
try:
validated = self._pstruct_schema.deserialize(pstruct)
except Invalid as exc:
raise Invalid(field.schema, text_("Invalid pstruct: %s" % exc))
minx = validated['minx']
miny = validated['miny']
maxx = validated['maxx']
maxy = validated['maxy']
if not minx and not minx and not maxx and not maxy:
return null
result = ','.join([minx, miny, maxx, maxy])
if not minx or not miny or not maxx or not maxy:
raise Invalid(field.schema, 'Incomplete bbox', result)
return result
def get_schema_from_relationship(self, prop: RelationshipProperty,
overrides: dict) -> SchemaNode:
"""Build and return a :class:`colander.SchemaNode` for a relationship.
The mapping process will translate one-to-many and many-to-many
relationships from SQLAlchemy into a ``Sequence`` of ``Mapping`` nodes
in Colander, and translate one-to-one and many-to-one relationships
into a ``Mapping`` node in Colander. The related class involved in the
relationship will be recursively mapped by ColanderAlchemy as part of
this process, following the same mapping process.
This method uses information stored in the relationship within
the ``info`` that was passed to the relationship on creation.
This means that ``Colander`` options can be specified
declaratively in ``SQLAlchemy`` models using the ``info``
argument that you can pass to
:meth:`sqlalchemy.orm.relationship`.
For all relationships, the settings will only be applied to the outer
Sequence or Mapping. To customise the inner schema node, create the
attribute ``__colanderalchemy_config__`` on the related model with a
dict-like structure corresponding to the Colander options that should
be customised.
Arguments/Keywords
:param prop: RelationshipProperty
:param overrides: Dictionary with attributes to be overriden.
:return: SchemaNode instance.
"""
# The name of the SchemaNode is the ColumnProperty key.
name = self._change_name(prop)
kwargs = {'name': name}
decl_overrides = prop.info.get(self.sqla_info_key, {}).copy()
self.declarative_overrides[name] = decl_overrides.copy()
class_ = prop.mapper.class_
if decl_overrides.pop('exclude', False):
logger.debug(
f'Relationship {name} skipped due to declarative overrides')
return None
for key in ['name', 'typ']:
self.check_overrides(name, key, {}, decl_overrides, overrides)
children = self._relationship_config(name, 'children', overrides,
decl_overrides)
includes = self._relationship_config(name, 'includes', overrides,
decl_overrides)
excludes = self._relationship_config(name, 'excludes', overrides,
decl_overrides)
rel_overrides = self._relationship_config(name, 'overrides', overrides,
decl_overrides)
# Add default values for missing parameters.
missing = []
if prop.innerjoin:
# Inner joined relationships imply it is mandatory
missing = required
kwargs['missing'] = missing
kwargs.update(decl_overrides)
kwargs.update(overrides)
if children is not None:
node_type = Mapping()
if prop.uselist:
# xToMany relationships.
node_type = Sequence()
return SchemaNode(node_type, *children, **kwargs)
node = BriefySchemaNode(class_,
name=name,
includes=includes,
excludes=excludes,
overrides=rel_overrides,
missing=missing,
parents_=self.parents_ + [self.class_])
if prop.uselist:
node = SchemaNode(Sequence(), node, **kwargs)
node.name = name
return node
def schema_type():
return Mapping(unknown='raise')
def schema_type(self, **kw):
return Mapping(unknown='raise')
def serialize(self, node, appstruct):
self.unknown = "ignore"
return BaseMapping.serialize(self, node, appstruct)
def serialize(self, node, appstruct):
self.unknown = "ignore"
return BaseMapping.serialize(self, node, appstruct)
def deserialize(self, node, cstruct):
self.unknown = "raise"
return BaseMapping.deserialize(self, node, cstruct)
def schema_type(self, **kw):
return Mapping(unknown='preserve')
def mapping(name, unknown='preserve', **kw):
return _node(Mapping(unknown=unknown), name=name, **kw)
import colander
from colander import Mapping, SchemaNode
from deform import widget
from deform.widget import MappingWidget, SequenceWidget
registry = widget.default_resource_registry
registry.set_js_resources(
'magicsuggest', None,
'c2cgeoportal_admin:node_modules/magicsuggest-alpine/magicsuggest-min.js')
registry.set_css_resources(
'magicsuggest', None,
'c2cgeoportal_admin:node_modules/magicsuggest-alpine/magicsuggest-min.css')
# temporary workaround for https://github.com/Pylons/deform/pull/369
widget.DateTimeInputWidget._pstruct_schema = SchemaNode( # pylint: disable=protected-access
Mapping(),
SchemaNode(widget._StrippedString(), name='date'), # pylint: disable=protected-access
SchemaNode(widget._StrippedString(), name='time'), # pylint: disable=protected-access
SchemaNode(widget._StrippedString(), name='date_submit', missing=''), # pylint: disable=protected-access
SchemaNode(widget._StrippedString(), name='time_submit', missing='') # pylint: disable=protected-access
)
class ChildWidget(MappingWidget):
template = 'child'
def serialize(self, field, cstruct, **kw):
from c2cgeoportal_commons.models.main import TreeItem
if cstruct['treeitem_id'] == colander.null:
kw['treeitem'] = TreeItem()
def deserialize(self, node, cstruct):
self.unknown = "raise"
return BaseMapping.deserialize(self, node, cstruct)
def __init__(self):
super(ModelSchema, self).__init__(Mapping())
# Child node for ``records`` will be added during deserialization
self.add(DefinitionSchema(name='definition'))
self.add(PermissionsSchema(name='permissions', missing={}))
def get_schema_from_relationship(self, prop, overrides):
""" Build and return a :class:`colander.SchemaNode` for a relationship.
The mapping process will translate one-to-many and many-to-many
relationships from SQLAlchemy into a ``Sequence`` of ``Mapping`` nodes
in Colander, and translate one-to-one and many-to-one relationships
into a ``Mapping`` node in Colander. The related class involved in the
relationship will be recursively mapped by ColanderAlchemy as part of
this process, following the same mapping process.
This method uses information stored in the relationship within
the ``info`` that was passed to the relationship on creation.
This means that ``Colander`` options can be specified
declaratively in ``SQLAlchemy`` models using the ``info``
argument that you can pass to
:meth:`sqlalchemy.orm.relationship`.
For all relationships, the settings will only be applied to the outer
Sequence or Mapping. To customise the inner schema node, create the
attribute ``__colanderalchemy_config__`` on the related model with a
dict-like structure corresponding to the Colander options that should
be customised.
Arguments/Keywords
prop
A given :class:`sqlalchemy.orm.properties.RelationshipProperty`
instance that represents the relationship being mapped.
overrides
A dict-like structure that consists of schema attributes to
override imperatively. Values provides as part of :attr:`overrides`
will take precendence over all others. Example keys include
``children``, ``includes``, ``excludes``, ``overrides``.
"""
# The name of the SchemaNode is the ColumnProperty key.
name = prop.key
kwargs = dict(name=name)
declarative_overrides = prop.info.get(self.sqla_info_key, {}).copy()
self.declarative_overrides[name] = declarative_overrides.copy()
class_ = prop.mapper.class_
key = 'exclude'
if declarative_overrides.pop(key, False):
log.debug('Relationship %s skipped due to declarative overrides',
name)
return None
if overrides.pop(key, False):
log.debug('Relationship %s skipped due to imperative overrides',
name)
return None
for key in ['name', 'typ']:
self.check_overrides(name, key, {}, declarative_overrides,
overrides)
key = 'children'
imperative_children = overrides.pop(key, None)
declarative_children = declarative_overrides.pop(key, None)
if imperative_children is not None:
children = imperative_children
msg = 'Relationship %s: %s overridden imperatively.'
log.debug(msg, name, key)
elif declarative_children is not None:
children = declarative_children
msg = 'Relationship %s: %s overridden via declarative.'
log.debug(msg, name, key)
else:
children = None
key = 'includes'
imperative_includes = overrides.pop(key, None)
declarative_includes = declarative_overrides.pop(key, None)
if imperative_includes is not None:
includes = imperative_includes
msg = 'Relationship %s: %s overridden imperatively.'
log.debug(msg, name, key)
elif declarative_includes is not None:
includes = declarative_includes
msg = 'Relationship %s: %s overridden via declarative.'
log.debug(msg, name, key)
else:
includes = None
key = 'excludes'
imperative_excludes = overrides.pop(key, None)
declarative_excludes = declarative_overrides.pop(key, None)
if imperative_excludes is not None:
excludes = imperative_excludes
msg = 'Relationship %s: %s overridden imperatively.'
log.debug(msg, name, key)
elif declarative_excludes is not None:
excludes = declarative_excludes
msg = 'Relationship %s: %s overridden via declarative.'
log.debug(msg, name, key)
else:
excludes = None
key = 'overrides'
imperative_rel_overrides = overrides.pop(key, None)
declarative_rel_overrides = declarative_overrides.pop(key, None)
if imperative_rel_overrides is not None:
rel_overrides = imperative_rel_overrides
msg = 'Relationship %s: %s overridden imperatively.'
log.debug(msg, name, key)
elif declarative_rel_overrides is not None:
rel_overrides = declarative_rel_overrides
msg = 'Relationship %s: %s overridden via declarative.'
log.debug(msg, name, key)
else:
rel_overrides = None
# Add default values for missing parameters.
if prop.innerjoin:
# Inner joined relationships imply it is mandatory
missing = required
else:
# Any other join is thus optional
missing = []
kwargs['missing'] = missing
kwargs.update(declarative_overrides)
kwargs.update(overrides)
if children is not None:
if prop.uselist:
# xToMany relationships.
return SchemaNode(Sequence(), *children, **kwargs)
else:
# xToOne relationships.
return SchemaNode(Mapping(), *children, **kwargs)
if prop.uselist:
node = SQLAlchemySchemaNode(class_,
name=name,
includes=includes,
excludes=excludes,
overrides=rel_overrides,
missing=missing,
parents_=self.parents_ + [self.class_])
node = SchemaNode(Sequence(), node, **kwargs)
else:
kwargs['name'] = name
kwargs['includes'] = includes
kwargs['excludes'] = excludes
kwargs['overrides'] = rel_overrides
kwargs['parents_'] = self.parents_ + [self.class_]
node = SQLAlchemySchemaNode(class_, **kwargs)
node.name = name
return node
class InheritedSchema(TestingSchema):
foo = SchemaNode(Int(), missing=1)
class ToBoundSchema(TestingSchema):
foo = SchemaNode(Int(), missing=1)
bazinga = SchemaNode(String(),
type='str',
location="body",
validator=deferred_validator)
class DropSchema(MappingSchema):
foo = SchemaNode(String(), type='str', missing=drop)
bar = SchemaNode(String(), type='str')
imperative_schema = SchemaNode(Mapping())
imperative_schema.add(SchemaNode(String(), name='foo', type='str'))
imperative_schema.add(
SchemaNode(String(), name='bar', type='str', location="body"))
imperative_schema.add(
SchemaNode(String(), name='baz', type='str', location="querystring"))
class TestingSchemaWithHeader(MappingSchema):
foo = SchemaNode(String(), type='str')
bar = SchemaNode(String(), type='str', location="body")
baz = SchemaNode(String(), type='str', location="querystring")
qux = SchemaNode(String(), type='str', location="header")
class TestSchemas(TestCase):
def test_colander_integration(self):
# not specifying body should act the same way as specifying it
def __init__(self,
class_,
includes=None,
excludes=None,
overrides=None,
unknown='ignore',
**kw):
""" Initialise the given mapped schema according to options provided.
Arguments/Keywords
class\_
An ``SQLAlchemy`` mapped class that you want a ``Colander`` schema
to be generated for.
To declaratively customise ``Colander`` ``SchemaNode`` options,
add a ``__colanderalchemy_config__`` attribute to your initial
class declaration like so::
class MyModel(Base):
__colanderalchemy_config__ = {'title': 'Custom title',
'description': 'Sample'}
...
includes
Iterable of attributes to include from the resulting schema. Using
this option will ensure *only* the explicitly mentioned attributes
are included and *all others* are excluded.
``includes`` can be included in the ``__colanderalchemy_config__``
dict on a class to declaratively customise the resulting schema.
Explicitly passing this option as an argument takes precedence over
the declarative configuration.
Incompatible with :attr:`excludes`. Default: None.
excludes
Iterable of attributes to exclude from the resulting schema. Using
this option will ensure *only* the explicitly mentioned attributes
are excluded and *all others* are included.
``excludes`` can be included in the ``__colanderalchemy_config__``
dict on a class to declaratively customise the resulting schema.
Explicitly passing this option as an argument takes precedence over
the declarative configuration.
Incompatible with :attr:`includes`. Default: None.
overrides
A dict-like structure that consists of schema attributes to
override imperatively. Values provides as part of :attr:`overrides`
will take precendence over all others.
``overrides`` can be included in the ``__colanderalchemy_config__``
dict on a class to declaratively customise the resulting schema.
Explicitly passing this option as an argument takes precedence over
the declarative configuration.
Default: None.
unknown
Represents the `unknown` argument passed to
:class:`colander.Mapping`.
The ``unknown`` argument passed to :class:`colander.Mapping`, which
defaults to ``'ignore'``, can be set by adding an ``unknown`` key to
the ``__colanderalchemy_config__`` dict. For example::
class MyModel(Base):
__colanderalchemy_config__ = {'title': 'Custom title',
'description': 'Sample',
'unknown': 'preserve'}
...
In contrast to the other options in ``__colanderalchemy_config__``,
the ``unknown`` option is not directly passed to
:class:`colander.SchemaNode`. Instead, it is passed to the
:class:`colander.Mapping` object, which itself is passed to
:class:`colander.SchemaNode`.
From Colander:
``unknown`` controls the behavior of this type when an unknown
key is encountered in the cstruct passed to the deserialize
method of this instance.
Default: 'ignore'
\*\*kw
Represents *all* other options able to be passed to a
:class:`colander.SchemaNode`. Keywords passed will influence the
resulting mapped schema accordingly (for instance, passing
``title='My Model'`` means the returned schema will have its
``title`` attribute set accordingly.
See
http://docs.pylonsproject.org/projects/colander/en/latest/basics.html
for more information.
"""
self.inspector = inspect(class_)
kwargs = kw.copy()
# Obtain configuration specific from the mapped class
kwargs.update(getattr(self.inspector.class_, self.ca_class_key, {}))
declarative_includes = kwargs.pop('includes', {})
declarative_excludes = kwargs.pop('excludes', {})
declarative_overrides = kwargs.pop('overrides', {})
unknown = kwargs.pop('unknown', unknown)
parents_ = kwargs.pop('parents_', [])
# The default type of this SchemaNode is Mapping.
super(SQLAlchemySchemaNode, self).__init__(Mapping(unknown), **kwargs)
self.class_ = class_
self.parents_ = parents_
self.includes = includes or declarative_includes
self.excludes = excludes or declarative_excludes
self.overrides = overrides or declarative_overrides
self.unknown = unknown
self.declarative_overrides = {}
self.kwargs = kwargs or {}
self.add_nodes(self.includes, self.excludes, self.overrides)
def get_schema_from_relationship(self, prop, overrides):
"""Extended for property support."""
# The name of the SchemaNode is the ColumnProperty key.
name = prop.key
kwargs = dict(name=name)
declarative_overrides = prop.info.get(self.sqla_info_key, {}).copy()
self.declarative_overrides[name] = declarative_overrides.copy()
class_ = prop.mapper
if declarative_overrides.pop('exclude', False):
log.debug('Relationship %s skipped due to declarative overrides',
name)
return None
for key in ['name', 'typ']:
self.check_overrides(name, key, {}, declarative_overrides,
overrides)
key = 'children'
imperative_children = overrides.pop(key, None)
declarative_children = declarative_overrides.pop(key, None)
if imperative_children is not None:
children = imperative_children
msg = 'Relationship %s: %s overridden imperatively.'
log.debug(msg, name, key)
elif declarative_children is not None:
children = declarative_children
msg = 'Relationship %s: %s overridden via declarative.'
log.debug(msg, name, key)
else:
children = None
key = 'includes'
imperative_includes = overrides.pop(key, None)
declarative_includes = declarative_overrides.pop(key, None)
if imperative_includes is not None:
includes = imperative_includes
msg = 'Relationship %s: %s overridden imperatively.'
log.debug(msg, name, key)
elif declarative_includes is not None:
includes = declarative_includes
msg = 'Relationship %s: %s overridden via declarative.'
log.debug(msg, name, key)
else:
includes = None
# TODO: Utmost piece of garbage here.. remove this
if not self.automatic_relationships:
if name not in (self.includes or ()):
log.debug("Does not construct relationship for %s unless explicitly included", name)
return None
if self.relationship_overrides:
result = self.relationship_overrides(self, name, prop, class_)
if result == TypeOverridesHandling.drop:
return None
elif result == TypeOverridesHandling.unknown:
pass
else:
assert isinstance(result, colander.SchemaNode)
return result
key = 'excludes'
imperative_excludes = overrides.pop(key, None)
declarative_excludes = declarative_overrides.pop(key, None)
if imperative_excludes is not None:
excludes = imperative_excludes
msg = 'Relationship %s: %s overridden imperatively.'
log.debug(msg, name, key)
elif declarative_excludes is not None:
excludes = declarative_excludes
msg = 'Relationship %s: %s overridden via declarative.'
log.debug(msg, name, key)
else:
excludes = None
# see issue #25 in ColanderAlchemy for possible patch
if includes is None and excludes is None:
includes = [p.key for p in inspect(class_).column_attrs]
key = 'overrides'
imperative_rel_overrides = overrides.pop(key, None)
declarative_rel_overrides = declarative_overrides.pop(key, None)
if imperative_rel_overrides is not None:
rel_overrides = imperative_rel_overrides
msg = 'Relationship %s: %s overridden imperatively.'
log.debug(msg, name, key)
elif declarative_rel_overrides is not None:
rel_overrides = declarative_rel_overrides
msg = 'Relationship %s: %s overridden via declarative.'
log.debug(msg, name, key)
else:
rel_overrides = None
# Add default values for missing parameters.
if prop.innerjoin:
# Inner joined relationships imply it is mandatory
missing = required
else:
# Any other join is thus optional
missing = []
kwargs['missing'] = missing
kwargs.update(declarative_overrides)
kwargs.update(overrides)
if children is not None:
if prop.uselist:
# xToMany relationships.
return SchemaNode(Sequence(), *children, **kwargs)
else:
# xToOne relationships.
return SchemaNode(Mapping(), *children, **kwargs)
node = PropertyAwareSQLAlchemySchemaNode(class_,
name=name,
includes=includes,
excludes=excludes,
overrides=rel_overrides,
missing=missing,
type_overrides=self.type_overrides,
relationship_overrides=self.relationship_overrides)
if prop.uselist:
node = SchemaNode(Sequence(), node, **kwargs)
node.name = name
return node
def schema_type():
return Mapping(unknown='preserve')
