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:
             return location.getlist(self.name)

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

@@ -18,6 +18,7 @@
     CastError, InvalidSchemaValue,
     UnmarshallerError, UnmarshalValueError, UnmarshalError,
 )
+from openapi_core.schema.schemas.types import NoValue
 from openapi_core.schema.schemas.util import (
     forcebool, format_date, format_datetime, format_byte, format_uuid,
     format_number,
@@ -46,16 +47,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
@@ -84,6 +85,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
 
@@ -100,6 +103,9 @@ def to_dict(self):
     def __getitem__(self, name):
         return self.properties[name]
 
+    def has_default(self):
+        return not self.default is NoValue
+
     def get_all_properties(self):
         properties = self.properties.copy()
 
@@ -149,7 +155,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()
@@ -198,51 +204,17 @@ 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,
@@ -276,79 +248,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

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

openapi_core/schema/schemas/types.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)