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

@@ -4,6 +4,7 @@
 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
@@ -21,7 +22,6 @@ 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)
         properties_spec = schema_deref.get('properties', None)
@@ -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

@@ -46,16 +46,16 @@ class Schema(object):
     }
 
     def __init__(
-            self, schema_type=None, model=None, properties=None, items=None,
+            self, schema_type=None, properties=None, items=None,
             schema_format=None, required=None, default=None, 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
@@ -84,6 +84,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
 
@@ -198,50 +200,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]
-        try:
-            unmarshalled = unmarshal_callable(value)
-        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,
+        from openapi_core.unmarshalling.schemas.factories import (
+            SchemaUnmarshallersFactory,
         )
-
-        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
+        unmarshallers_factory = SchemaUnmarshallersFactory(
+            custom_formatters)
+        unmarshaller = unmarshallers_factory.create(self)
+        return unmarshaller(value, strict=strict)
 
     def _unmarshal_any(self, value, custom_formatters=None, strict=True):
         types_resolve_order = [
@@ -276,79 +241,3 @@ def _unmarshal_any(self, value, custom_formatters=None, strict=True):
 
         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

@@ -0,0 +1,66 @@
+import attr
+
+from openapi_core.exceptions import OpenAPIError
+
+
+class UnmarshalError(OpenAPIError):
+    """Schema unmarshal operation error"""
+    pass
+
+
+class UnmarshallerError(UnmarshalError):
+    """Unmarshaller error"""
+    pass
+
+
+@attr.s(hash=True)
+class UnmarshalValueError(UnmarshalError):
+    """Failed to unmarshal value to type"""
+    value = attr.ib()
+    type = attr.ib()
+    original_exception = attr.ib(default=None)
+
+    def __str__(self):
+        return (
+            "Failed to unmarshal value {value} to type {type}: {exception}"
+        ).format(
+            value=self.value, type=self.type,
+            exception=self.original_exception,
+        )
+
+
+@attr.s(hash=True)
+class InvalidCustomFormatSchemaValue(UnmarshallerError):
+    """Value failed to format with custom formatter"""
+    value = attr.ib()
+    type = attr.ib()
+    original_exception = attr.ib()
+
+    def __str__(self):
+        return (
+            "Failed to format value {value} to format {type}: {exception}"
+        ).format(
+            value=self.value, type=self.type,
+            exception=self.original_exception,
+        )
+
+
+@attr.s(hash=True)
+class FormatterNotFoundError(UnmarshallerError):
+    """Formatter not found to unmarshal"""
+    type_format = attr.ib()
+
+    def __str__(self):
+        return "Formatter not found for {format} format".format(
+            format=self.type_format)
+
+
+@attr.s(hash=True)
+class UnmarshallerStrictTypeError(UnmarshallerError):
+    value = attr.ib()
+    types = attr.ib()
+    
+    def __str__(self):
+        types = ', '.join(list(map(str, self.types)))
+        return "Value {value} is not one of types: {types}".format(
+            value=self.value, types=types)

openapi_core/unmarshalling/__init__.py

@@ -0,0 +1,60 @@
+from collections import defaultdict
+from functools import partial
+import warnings
+
+from openapi_core.schema.schemas.enums import SchemaType, SchemaFormat
+from openapi_core.unmarshalling.schemas.exceptions import FormatterNotFoundError
+from openapi_core.unmarshalling.schemas.unmarshallers import (
+    StringUnmarshaller, IntegerUnmarshaller, NumberUnmarshaller,
+    BooleanUnmarshaller, ArrayUnmarshaller, ObjectUnmarshaller,
+    AnyUnmarshaller,
+)
+
+
+class SchemaUnmarshallersFactory(object):
+
+    PRIMITIVE_UNMARSHALLERS = {
+        SchemaType.STRING: StringUnmarshaller,
+        SchemaType.INTEGER: IntegerUnmarshaller,
+        SchemaType.NUMBER: NumberUnmarshaller,
+        SchemaType.BOOLEAN: BooleanUnmarshaller,
+    }
+    COMPLEX_UNMARSHALLERS = {
+        SchemaType.ARRAY: ArrayUnmarshaller,
+        SchemaType.OBJECT: ObjectUnmarshaller,
+        SchemaType.ANY: AnyUnmarshaller,
+    }
+
+    def __init__(self, custom_formatters=None):
+        self.custom_formatters = custom_formatters
+
+    def create(self, schema, type_override=None):
+        """Create unmarshaller from the schema."""
+        if schema.deprecated:
+            warnings.warn("The schema is deprecated", DeprecationWarning)
+
+        schema_type = type_override or schema.type
+        if schema_type in self.PRIMITIVE_UNMARSHALLERS:
+            klass = self.PRIMITIVE_UNMARSHALLERS[schema_type]
+            kwargs = {}
+
+        elif schema_type in self.COMPLEX_UNMARSHALLERS:
+            klass = self.COMPLEX_UNMARSHALLERS[schema_type]
+            kwargs = dict(schema=schema, unmarshallers_factory=self)
+
+        formatter = self.get_formatter(klass.FORMATTERS, schema.format)
+
+        if formatter is None:
+            raise FormatterNotFoundError(schema.format)
+
+        return klass(formatter, **kwargs)
+
+    def get_formatter(self, formatters, type_format=SchemaFormat.NONE):
+        try:
+            schema_format = SchemaFormat(type_format)
+        except ValueError:
+            return self.custom_formatters.get(type_format)
+        else:
+            if schema_format == SchemaFormat.NONE:
+                return lambda x: x
+            return formatters.get(schema_format)