unmarshalling formatters

Author: p1c2u

openapi_core/schema/media_types/models.py

@@ -3,11 +3,10 @@
 
 from openapi_core.schema.media_types.exceptions import InvalidMediaTypeValue
 from openapi_core.schema.media_types.util import json_loads
-from openapi_core.schema.schemas.exceptions import (
-    ValidateError,
-)
 from openapi_core.casting.schemas.exceptions import CastError
-from openapi_core.unmarshalling.schemas.exceptions import UnmarshalError
+from openapi_core.unmarshalling.schemas.exceptions import (
+    UnmarshalError, ValidateError,
+)
 
 
 MEDIA_TYPE_DESERIALIZERS = {
@@ -53,13 +52,8 @@ def unmarshal(self, value, custom_formatters=None, resolver=None):
         if not self.schema:
             return value
 
-        try:
-            self.schema.validate(value, resolver=resolver)
-        except ValidateError as exc:
-            raise InvalidMediaTypeValue(exc)
-
         try:
             return self.schema.unmarshal(
-                value, custom_formatters=custom_formatters)
-        except UnmarshalError as exc:
+                value, resolver=resolver, custom_formatters=custom_formatters)
+        except (ValidateError, UnmarshalError) as exc:
             raise InvalidMediaTypeValue(exc)

openapi_core/schema/parameters/models.py

@@ -10,11 +10,10 @@
     EmptyParameterValue,
 )
 from openapi_core.schema.schemas.enums import SchemaType
-from openapi_core.schema.schemas.exceptions import (
-    ValidateError,
-)
 from openapi_core.casting.schemas.exceptions import CastError
-from openapi_core.unmarshalling.schemas.exceptions import UnmarshalError
+from openapi_core.unmarshalling.schemas.exceptions import (
+    UnmarshalError, ValidateError,
+)
 
 log = logging.getLogger(__name__)
 
@@ -120,16 +119,11 @@ def unmarshal(self, value, custom_formatters=None, resolver=None):
         if not self.schema:
             return value
 
-        try:
-            self.schema.validate(value, resolver=resolver)
-        except ValidateError as exc:
-            raise InvalidParameterValue(self.name, exc)
-
         try:
             return self.schema.unmarshal(
                 value,
+                resolver=resolver,
                 custom_formatters=custom_formatters,
-                strict=True,
             )
-        except UnmarshalError as exc:
+        except (ValidateError, UnmarshalError) as exc:
             raise InvalidParameterValue(self.name, exc)

openapi_core/schema/schemas/exceptions.py

@@ -1,31 +1,5 @@
-import attr
-
 from openapi_core.schema.exceptions import OpenAPIMappingError
 
 
 class OpenAPISchemaError(OpenAPIMappingError):
     pass
-
-
-class ValidateError(OpenAPISchemaError):
-    """Schema validate operation error"""
-    pass
-
-
-@attr.s(hash=True)
-class InvalidSchemaValue(ValidateError):
-    value = attr.ib()
-    type = attr.ib()
-    _schema_errors = attr.ib(default=None)
-    _schema_errors_iter = attr.ib(factory=list)
-
-    @property
-    def schema_errors(self):
-        if self._schema_errors is None:
-            self._schema_errors = list(self._schema_errors_iter)
-        return self._schema_errors
-
-    def __str__(self):
-        return (
-            "Value {value} not valid for schema of type {type}: {errors}"
-        ).format(value=self.value, type=self.type, errors=self.schema_errors)

openapi_core/schema/schemas/models.py

@@ -3,12 +3,7 @@
 import logging
 import re
 
-from jsonschema.exceptions import ValidationError
-
-from openapi_core.schema_validator import OAS30Validator
-from openapi_core.schema_validator import oas30_format_checker
 from openapi_core.schema.schemas.enums import SchemaType
-from openapi_core.schema.schemas.exceptions import InvalidSchemaValue
 from openapi_core.schema.schemas.types import NoValue
 from openapi_core.unmarshalling.schemas.exceptions import (
     UnmarshalValueError,
@@ -110,30 +105,15 @@ def cast(self, value):
         except (ValueError, TypeError):
             raise CastError(value, self.type)
 
-    def get_validator(self, resolver=None):
-        return OAS30Validator(
-            self.__dict__,
-            resolver=resolver, format_checker=oas30_format_checker,
-        )
-
-    def validate(self, value, resolver=None):
-        validator = self.get_validator(resolver=resolver)
-        try:
-            return validator.validate(value)
-        except ValidationError:
-            errors_iter = validator.iter_errors(value)
-            raise InvalidSchemaValue(
-                value, self.type, schema_errors_iter=errors_iter)
-
-    def unmarshal(self, value, custom_formatters=None, strict=True):
+    def unmarshal(self, value, resolver=None, custom_formatters=None):
         """Unmarshal parameter from the value."""
         from openapi_core.unmarshalling.schemas.factories import (
             SchemaUnmarshallersFactory,
         )
         unmarshallers_factory = SchemaUnmarshallersFactory(
-            custom_formatters)
+            resolver, custom_formatters)
         unmarshaller = unmarshallers_factory.create(self)
         try:
-            return unmarshaller(value, strict=strict)
+            return unmarshaller(value)
         except ValueError as exc:
             raise UnmarshalValueError(value, self.type, exc)

openapi_core/schema_validator/_format.py

@@ -28,60 +28,41 @@
     DATETIME_RAISES += (ValueError, TypeError)
 
 
-class StrictFormatChecker(FormatChecker):
-
-    def check(self, instance, format):
-        if format not in self.checkers:
-            raise FormatError(
-                "Format checker for %r format not found" % (format, ))
-        return super(StrictFormatChecker, self).check(
-            instance, format)
-
-
-oas30_format_checker = StrictFormatChecker()
-
-
-@oas30_format_checker.checks('int32')
 def is_int32(instance):
     return isinstance(instance, integer_types)
 
 
-@oas30_format_checker.checks('int64')
 def is_int64(instance):
     return isinstance(instance, integer_types)
 
 
-@oas30_format_checker.checks('float')
 def is_float(instance):
     return isinstance(instance, float)
 
 
-@oas30_format_checker.checks('double')
 def is_double(instance):
     # float has double precision in Python
     # It's double in CPython and Jython
     return isinstance(instance, float)
 
 
-@oas30_format_checker.checks('binary')
 def is_binary(instance):
     return isinstance(instance, binary_type)
 
 
-@oas30_format_checker.checks('byte', raises=(binascii.Error, TypeError))
 def is_byte(instance):
     if isinstance(instance, text_type):
         instance = instance.encode()
 
-    return b64encode(b64decode(instance)) == instance
+    try:
+        return b64encode(b64decode(instance)) == instance
+    except TypeError:
+        return False
 
 
-@oas30_format_checker.checks("date-time", raises=DATETIME_RAISES)
 def is_datetime(instance):
-    if isinstance(instance, binary_type):
+    if not isinstance(instance, (binary_type, text_type)):
         return False
-    if not isinstance(instance, text_type):
-        return True
 
     if DATETIME_HAS_STRICT_RFC3339:
         return strict_rfc3339.validate_rfc3339(instance)
@@ -92,24 +73,60 @@ def is_datetime(instance):
     return True
 
 
-@oas30_format_checker.checks("date", raises=ValueError)
 def is_date(instance):
-    if isinstance(instance, binary_type):
+    if not isinstance(instance, (binary_type, text_type)):
         return False
-    if not isinstance(instance, text_type):
-        return True
+
     return datetime.strptime(instance, "%Y-%m-%d")
 
 
-@oas30_format_checker.checks("uuid", raises=AttributeError)
 def is_uuid(instance):
-    if isinstance(instance, binary_type):
-        return False
-    if not isinstance(instance, text_type):
-        return True
-    try:
-        uuid_obj = UUID(instance)
-    except ValueError:
+    if not isinstance(instance, (binary_type, text_type)):
         return False
 
-    return text_type(uuid_obj) == instance
+    if isinstance(instance, binary_type):
+        instance = instance.decode()
+
+    return text_type(UUID(instance)) == instance
+
+
+def is_password(instance):
+    return True
+
+
+class OASFormatChecker(FormatChecker):
+
+    checkers = {
+        'int32': (is_int32, ()),
+        'int64': (is_int64, ()),
+        'float': (is_float, ()),
+        'double': (is_double, ()),
+        'byte': (is_byte, (binascii.Error, TypeError)),
+        'binary': (is_binary, ()),
+        'date': (is_date, (ValueError, )),
+        'date-time': (is_datetime, DATETIME_RAISES),
+        'password': (is_password, ()),
+        # non standard
+        'uuid': (is_uuid, (AttributeError, ValueError)),
+    }
+
+    def check(self, instance, format):
+        if format not in self.checkers:
+            raise FormatError(
+                "Format checker for %r format not found" % (format, ))
+
+        func, raises = self.checkers[format]
+        result, cause = None, None
+        try:
+            result = func(instance)
+        except raises as e:
+            cause = e
+
+        if not result:
+            raise FormatError(
+                "%r is not a %r" % (instance, format), cause=cause,
+            )
+        return result
+
+
+oas30_format_checker = OASFormatChecker()

openapi_core/unmarshalling/schemas/exceptions.py

@@ -8,6 +8,11 @@ class UnmarshalError(OpenAPIError):
     pass
 
 
+class ValidateError(UnmarshalError):
+    """Schema validate operation error"""
+    pass
+
+
 class UnmarshallerError(UnmarshalError):
     """Unmarshaller error"""
     pass
@@ -29,6 +34,18 @@ def __str__(self):
         )
 
 
+@attr.s(hash=True)
+class InvalidSchemaValue(ValidateError):
+    value = attr.ib()
+    type = attr.ib()
+    schema_errors = attr.ib(factory=tuple)
+
+    def __str__(self):
+        return (
+            "Value {value} not valid for schema of type {type}: {errors}"
+        ).format(value=self.value, type=self.type, errors=self.schema_errors)
+
+
 @attr.s(hash=True)
 class InvalidCustomFormatSchemaValue(UnmarshallerError):
     """Value failed to format with custom formatter"""
@@ -53,14 +70,3 @@ class FormatterNotFoundError(UnmarshallerError):
     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/schemas/factories.py

@@ -1,6 +1,9 @@
+from copy import deepcopy
 import warnings
 
 from openapi_core.schema.schemas.enums import SchemaType, SchemaFormat
+from openapi_core.schema_validator import OAS30Validator
+from openapi_core.schema_validator import oas30_format_checker
 from openapi_core.unmarshalling.schemas.exceptions import (
     FormatterNotFoundError,
 )
@@ -25,7 +28,8 @@ class SchemaUnmarshallersFactory(object):
         SchemaType.ANY: AnyUnmarshaller,
     }
 
-    def __init__(self, custom_formatters=None):
+    def __init__(self, resolver=None, custom_formatters=None):
+        self.resolver = resolver
         if custom_formatters is None:
             custom_formatters = {}
         self.custom_formatters = custom_formatters
@@ -42,21 +46,31 @@ def create(self, schema, type_override=None):
 
         elif schema_type in self.COMPLEX_UNMARSHALLERS:
             klass = self.COMPLEX_UNMARSHALLERS[schema_type]
-            kwargs = dict(schema=schema, unmarshallers_factory=self)
+            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)
+        validator = self.get_validator(schema)
 
-    def get_formatter(self, formatters, type_format=SchemaFormat.NONE):
+        return klass(formatter, validator, **kwargs)
+
+    def get_formatter(self, default_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)
+            return default_formatters.get(schema_format)
+
+    def get_validator(self, schema):
+        format_checker = deepcopy(oas30_format_checker)
+        for name, formatter in self.custom_formatters.items():
+            format_checker.checks(name)(formatter.validate)
+        return OAS30Validator(
+            schema.__dict__,
+            resolver=self.resolver, format_checker=format_checker,
+        )