Move Unmarshallers to separate subpackage

Author: p1c2u

openapi_core/exceptions.py

@@ -0,0 +1,5 @@
+"""OpenAPI core exceptions module"""
+
+
+class OpenAPIError(Exception):
+    pass

openapi_core/schema/exceptions.py

@@ -1,8 +1,5 @@
 """OpenAPI core schema exceptions module"""
-
-
-class OpenAPIError(Exception):
-    pass
+from openapi_core.exceptions import OpenAPIError
 
 
 class OpenAPIMappingError(OpenAPIError):

openapi_core/schema/extensions/__init__.py

@@ -0,0 +1,16 @@
+"""OpenAPI core extensions generators module"""
+from six import iteritems
+
+from openapi_core.schema.extensions.models import Extension
+
+
+class ExtensionsGenerator(object):
+
+    def __init__(self, dereferencer):
+        self.dereferencer = dereferencer
+
+    def generate(self, item_spec):
+        for field_name, value in iteritems(item_spec):
+            if not field_name.startswith('x-'):
+                continue
+            yield field_name, Extension(field_name, value)

openapi_core/schema/extensions/generators.py

@@ -0,0 +1,9 @@
+"""OpenAPI core extensions models module"""
+
+
+class Extension(object):
+    """Represents an OpenAPI Extension."""
+
+    def __init__(self, field_name, value=None):
+        self.field_name = field_name
+        self.value = value

openapi_core/schema/extensions/models.py

@@ -81,10 +81,7 @@ def get_raw_value(self, request):
             if self.required:
                 raise MissingRequiredParameter(self.name)
 
-            if not self.schema or self.schema.default is None:
-                raise MissingParameter(self.name)
-
-            return self.schema.default
+            raise MissingParameter(self.name)
 
         if self.aslist and self.explode:
             if hasattr(location, 'getall'):

openapi_core/schema/parameters/models.py

@@ -4,9 +4,10 @@
 from six import iteritems
 
 from openapi_core.compat import lru_cache
+from openapi_core.schema.extensions.generators import ExtensionsGenerator
 from openapi_core.schema.properties.generators import PropertiesGenerator
 from openapi_core.schema.schemas.models import Schema
-from openapi_core.schema.schemas.types import Contribution
+from openapi_core.schema.schemas.types import Contribution, NoValue
 
 log = logging.getLogger(__name__)
 
@@ -21,9 +22,8 @@ def create(self, schema_spec):
 
         schema_type = schema_deref.get('type', None)
         schema_format = schema_deref.get('format')
-        model = schema_deref.get('x-model', None)
         required = schema_deref.get('required', False)
-        default = schema_deref.get('default', None)
+        default = schema_deref.get('default', NoValue)
         properties_spec = schema_deref.get('properties', None)
         items_spec = schema_deref.get('items', None)
         nullable = schema_deref.get('nullable', False)
@@ -47,6 +47,8 @@ def create(self, schema_spec):
         min_properties = schema_deref.get('minProperties', None)
         max_properties = schema_deref.get('maxProperties', None)
 
+        extensions = self.extensions_generator.generate(schema_deref)
+
         properties = None
         if properties_spec:
             properties = self.properties_generator.generate(properties_spec)
@@ -68,7 +70,7 @@ def create(self, schema_spec):
             additional_properties = self.create(additional_properties_spec)
 
         return Schema(
-            schema_type=schema_type, model=model, properties=properties,
+            schema_type=schema_type, properties=properties,
             items=items, schema_format=schema_format, required=required,
             default=default, nullable=nullable, enum=enum,
             deprecated=deprecated, all_of=all_of, one_of=one_of,
@@ -79,9 +81,15 @@ def create(self, schema_spec):
             exclusive_maximum=exclusive_maximum,
             exclusive_minimum=exclusive_minimum,
             min_properties=min_properties, max_properties=max_properties,
+            extensions=extensions,
             _source=schema_deref,
         )
 
+    @property
+    @lru_cache()
+    def extensions_generator(self):
+        return ExtensionsGenerator(self.dereferencer)
+
     @property
     @lru_cache()
     def properties_generator(self):

openapi_core/schema/schemas/factories.py

@@ -1,21 +1,18 @@
 """OpenAPI core schemas models module"""
 import attr
-import functools
 import logging
 from collections import defaultdict
 import re
-import warnings
 
 from six import iteritems
 from jsonschema.exceptions import ValidationError
 
-from openapi_core.extensions.models.factories import ModelFactory
 from openapi_core.schema.schemas._format import oas30_format_checker
 from openapi_core.schema.schemas.enums import SchemaType
 from openapi_core.schema.schemas.exceptions import (
-    CastError, InvalidSchemaValue,
-    UnmarshalValueError, UnmarshalError,
+    CastError, InvalidSchemaValue, UnmarshalValueError,
 )
+from openapi_core.schema.schemas.types import NoValue
 from openapi_core.schema.schemas.util import forcebool
 from openapi_core.schema.schemas.validators import OAS30Validator
 
@@ -41,16 +38,16 @@ class Schema(object):
     }
 
     def __init__(
-            self, schema_type=None, model=None, properties=None, items=None,
-            schema_format=None, required=None, default=None, nullable=False,
+            self, schema_type=None, properties=None, items=None,
+            schema_format=None, required=None, default=NoValue, nullable=False,
             enum=None, deprecated=False, all_of=None, one_of=None,
             additional_properties=True, min_items=None, max_items=None,
             min_length=None, max_length=None, pattern=None, unique_items=False,
             minimum=None, maximum=None, multiple_of=None,
             exclusive_minimum=False, exclusive_maximum=False,
-            min_properties=None, max_properties=None, _source=None):
+            min_properties=None, max_properties=None, extensions=None,
+            _source=None):
         self.type = SchemaType(schema_type)
-        self.model = model
         self.properties = properties and dict(properties) or {}
         self.items = items
         self.format = schema_format
@@ -79,6 +76,8 @@ def __init__(
         self.max_properties = int(max_properties)\
             if max_properties is not None else None
 
+        self.extensions = extensions and dict(extensions) or {}
+
         self._all_required_properties_cache = None
         self._all_optional_properties_cache = None
 
@@ -95,6 +94,9 @@ def to_dict(self):
     def __getitem__(self, name):
         return self.properties[name]
 
+    def has_default(self):
+        return self.default is not NoValue
+
     def get_all_properties(self):
         properties = self.properties.copy()
 
@@ -144,7 +146,7 @@ def get_cast_mapping(self):
 
     def cast(self, value):
         """Cast value from string to schema type"""
-        if value is None:
+        if value in (None, NoValue):
             return value
 
         cast_mapping = self.get_cast_mapping()
@@ -158,28 +160,6 @@ def cast(self, value):
     def _cast_collection(self, value):
         return list(map(self.items.cast, value))
 
-    def get_unmarshal_mapping(self, custom_formatters=None, strict=True):
-        primitive_unmarshallers = self.get_primitive_unmarshallers(
-            custom_formatters=custom_formatters)
-
-        primitive_unmarshallers_partial = dict(
-            (t, functools.partial(u, type_format=self.format, strict=strict))
-            for t, u in primitive_unmarshallers.items()
-        )
-
-        def pass_defaults(f):
-            return functools.partial(
-                f, custom_formatters=custom_formatters, strict=strict)
-        mapping = self.DEFAULT_UNMARSHAL_CALLABLE_GETTER.copy()
-        mapping.update(primitive_unmarshallers_partial)
-        mapping.update({
-            SchemaType.ANY: pass_defaults(self._unmarshal_any),
-            SchemaType.ARRAY: pass_defaults(self._unmarshal_collection),
-            SchemaType.OBJECT: pass_defaults(self._unmarshal_object),
-        })
-
-        return defaultdict(lambda: lambda x: x, mapping)
-
     def get_validator(self, resolver=None):
         return OAS30Validator(
             self.__dict__,
@@ -197,162 +177,13 @@ def validate(self, value, resolver=None):
 
     def unmarshal(self, value, custom_formatters=None, strict=True):
         """Unmarshal parameter from the value."""
-        if self.deprecated:
-            warnings.warn("The schema is deprecated", DeprecationWarning)
-        if value is None:
-            if not self.nullable:
-                raise UnmarshalError(
-                    "Null value for non-nullable schema", value, self.type)
-            return self.default
-
-        if self.enum and value not in self.enum:
-            raise UnmarshalError("Invalid value for enum: {0}".format(value))
-
-        unmarshal_mapping = self.get_unmarshal_mapping(
-            custom_formatters=custom_formatters, strict=strict)
-
-        if self.type is not SchemaType.STRING and value == '':
-            return None
-
-        unmarshal_callable = unmarshal_mapping[self.type]
+        from openapi_core.unmarshalling.schemas.factories import (
+            SchemaUnmarshallersFactory,
+        )
+        unmarshallers_factory = SchemaUnmarshallersFactory(
+            custom_formatters)
+        unmarshaller = unmarshallers_factory.create(self)
         try:
-            unmarshalled = unmarshal_callable(value)
+            return unmarshaller(value, strict=strict)
         except ValueError as exc:
             raise UnmarshalValueError(value, self.type, exc)
-
-        return unmarshalled
-
-    def get_primitive_unmarshallers(self, **options):
-        from openapi_core.schema.schemas.unmarshallers import (
-            StringUnmarshaller, BooleanUnmarshaller, IntegerUnmarshaller,
-            NumberUnmarshaller,
-        )
-
-        unmarshallers_classes = {
-            SchemaType.STRING: StringUnmarshaller,
-            SchemaType.BOOLEAN: BooleanUnmarshaller,
-            SchemaType.INTEGER: IntegerUnmarshaller,
-            SchemaType.NUMBER: NumberUnmarshaller,
-        }
-
-        unmarshallers = dict(
-            (t, klass(**options))
-            for t, klass in unmarshallers_classes.items()
-        )
-
-        return unmarshallers
-
-    def _unmarshal_any(self, value, custom_formatters=None, strict=True):
-        types_resolve_order = [
-            SchemaType.OBJECT, SchemaType.ARRAY, SchemaType.BOOLEAN,
-            SchemaType.INTEGER, SchemaType.NUMBER, SchemaType.STRING,
-        ]
-        unmarshal_mapping = self.get_unmarshal_mapping()
-        if self.one_of:
-            result = None
-            for subschema in self.one_of:
-                try:
-                    unmarshalled = subschema.unmarshal(
-                        value, custom_formatters)
-                except UnmarshalError:
-                    continue
-                else:
-                    if result is not None:
-                        log.warning("multiple valid oneOf schemas found")
-                        continue
-                    result = unmarshalled
-
-            if result is None:
-                log.warning("valid oneOf schema not found")
-
-            return result
-        else:
-            for schema_type in types_resolve_order:
-                unmarshal_callable = unmarshal_mapping[schema_type]
-                try:
-                    return unmarshal_callable(value)
-                except (UnmarshalError, ValueError):
-                    continue
-
-        log.warning("failed to unmarshal any type")
-        return value
-
-    def _unmarshal_collection(
-            self, value, custom_formatters=None, strict=True):
-        if not isinstance(value, (list, tuple)):
-            raise ValueError(
-                "Invalid value for collection: {0}".format(value))
-
-        f = functools.partial(
-            self.items.unmarshal,
-            custom_formatters=custom_formatters, strict=strict,
-        )
-        return list(map(f, value))
-
-    def _unmarshal_object(self, value, model_factory=None,
-                          custom_formatters=None, strict=True):
-        if not isinstance(value, (dict, )):
-            raise ValueError("Invalid value for object: {0}".format(value))
-
-        model_factory = model_factory or ModelFactory()
-
-        if self.one_of:
-            properties = None
-            for one_of_schema in self.one_of:
-                try:
-                    unmarshalled = self._unmarshal_properties(
-                        value, one_of_schema,
-                        custom_formatters=custom_formatters,
-                    )
-                except (UnmarshalError, ValueError):
-                    pass
-                else:
-                    if properties is not None:
-                        log.warning("multiple valid oneOf schemas found")
-                        continue
-                    properties = unmarshalled
-
-            if properties is None:
-                log.warning("valid oneOf schema not found")
-
-        else:
-            properties = self._unmarshal_properties(
-              value, custom_formatters=custom_formatters)
-
-        return model_factory.create(properties, name=self.model)
-
-    def _unmarshal_properties(self, value, one_of_schema=None,
-                              custom_formatters=None, strict=True):
-        all_props = self.get_all_properties()
-        all_props_names = self.get_all_properties_names()
-        all_req_props_names = self.get_all_required_properties_names()
-
-        if one_of_schema is not None:
-            all_props.update(one_of_schema.get_all_properties())
-            all_props_names |= one_of_schema.\
-                get_all_properties_names()
-            all_req_props_names |= one_of_schema.\
-                get_all_required_properties_names()
-
-        value_props_names = value.keys()
-        extra_props = set(value_props_names) - set(all_props_names)
-
-        properties = {}
-        if self.additional_properties is not True:
-            for prop_name in extra_props:
-                prop_value = value[prop_name]
-                properties[prop_name] = self.additional_properties.unmarshal(
-                    prop_value, custom_formatters=custom_formatters)
-
-        for prop_name, prop in iteritems(all_props):
-            try:
-                prop_value = value[prop_name]
-            except KeyError:
-                if not prop.nullable and not prop.default:
-                    continue
-                prop_value = prop.default
-
-            properties[prop_name] = prop.unmarshal(
-                prop_value, custom_formatters=custom_formatters)
-
-        return properties

openapi_core/schema/schemas/models.py

@@ -1,6 +1,9 @@
 import attr
 
 
+NoValue = object()
+
+
 @attr.s(hash=True)
 class Contribution(object):
     src_prop_name = attr.ib()