Get rid of object validator

Author: p1c2u

openapi_core/schema/media_types/models.py

@@ -51,12 +51,6 @@ def unmarshal(self, value, custom_formatters=None, resolver=None):
             raise InvalidMediaTypeValue(exc)
 
         try:
-            unmarshalled = self.schema.unmarshal(value, custom_formatters=custom_formatters)
-        except OpenAPISchemaError as exc:
-            raise InvalidMediaTypeValue(exc)
-
-        try:
-            return self.schema.obj_validate(
-                unmarshalled, custom_formatters=custom_formatters)
+            return self.schema.unmarshal(value, custom_formatters=custom_formatters)
         except OpenAPISchemaError as exc:
             raise InvalidMediaTypeValue(exc)

openapi_core/schema/parameters/models.py

@@ -123,16 +123,10 @@ def unmarshal(self, value, custom_formatters=None, resolver=None):
             raise InvalidParameterValue(self.name, exc)
 
         try:
-            unmarshalled = self.schema.unmarshal(
+            return self.schema.unmarshal(
                 value,
                 custom_formatters=custom_formatters,
                 strict=True,
             )
         except OpenAPISchemaError as exc:
             raise InvalidParameterValue(self.name, exc)
-
-        try:
-            return self.schema.obj_validate(
-                unmarshalled, custom_formatters=custom_formatters)
-        except OpenAPISchemaError as exc:
-            raise InvalidParameterValue(self.name, exc)

openapi_core/schema/schemas/_format.py

@@ -1,9 +1,105 @@
+from base64 import b64encode, b64decode
+import binascii
+from datetime import datetime
+from uuid import UUID
+
 from jsonschema._format import FormatChecker
-from six import binary_type
+from jsonschema.exceptions import FormatError
+from six import binary_type, text_type, integer_types
+
+
+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 = FormatChecker()
+
+@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 binary(value):
-    return isinstance(value, binary_type)
+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:
+    import strict_rfc3339
+except ImportError:
+    try:
+        import isodate
+    except ImportError:
+        pass
+    else:
+        @oas30_format_checker.checks(
+            "date-time", raises=(ValueError, isodate.ISO8601Error))
+        def is_datetime(instance):
+            if isinstance(instance, binary_type):
+                return False
+            if not isinstance(instance, text_type):
+                return True
+            return isodate.parse_datetime(instance)
+else:
+    @oas30_format_checker.checks("date-time")
+    def is_datetime(instance):
+        if isinstance(instance, binary_type):
+            return False
+        if not isinstance(instance, text_type):
+            return True
+        return strict_rfc3339.validate_rfc3339(instance)
+
+
+@oas30_format_checker.checks("date", raises=ValueError)
+def is_date(instance):
+    if isinstance(instance, binary_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:
+        return False
+
+    return text_type(uuid_obj) == instance

openapi_core/schema/schemas/_validators.py

@@ -1,4 +1,5 @@
-from jsonschema.exceptions import ValidationError
+from jsonschema._utils import find_additional_properties, extras_msg
+from jsonschema.exceptions import ValidationError, FormatError
 
 
 def type(validator, data_type, instance, schema):
@@ -9,6 +10,17 @@ def type(validator, data_type, instance, schema):
         yield ValidationError("%r is not of type %s" % (instance, data_type))
 
 
+def format(validator, format, instance, schema):
+    if instance is None:
+        return
+
+    if validator.format_checker is not None:
+        try:
+            validator.format_checker.check(instance, format)
+        except FormatError as error:
+            yield ValidationError(error.message, cause=error.cause)
+
+
 def items(validator, items, instance, schema):
     if not validator.is_type(instance, "array"):
         return
@@ -23,5 +35,24 @@ def nullable(validator, is_nullable, instance, schema):
         yield ValidationError("None for not nullable")
 
 
+def additionalProperties(validator, aP, instance, schema):
+    if not validator.is_type(instance, "object"):
+        return
+
+    extras = set(find_additional_properties(instance, schema))
+
+    if not extras:
+        return
+
+    if validator.is_type(aP, "object"):
+        for extra in extras:
+            for error in validator.descend(instance[extra], aP, path=extra):
+                yield error
+    elif validator.is_type(aP, "boolean"):
+        if not aP:
+            error = "Additional properties are not allowed (%s %s unexpected)"
+            yield ValidationError(error % extras_msg(extras))
+
+
 def not_implemented(validator, value, instance, schema):
     pass

openapi_core/schema/schemas/factories.py

@@ -1,9 +1,12 @@
 """OpenAPI core schemas factories module"""
 import logging
 
+from six import iteritems
+
 from openapi_core.compat import lru_cache
 from openapi_core.schema.properties.generators import PropertiesGenerator
 from openapi_core.schema.schemas.models import Schema
+from openapi_core.schema.schemas.types import Contribution
 
 log = logging.getLogger(__name__)
 
@@ -86,3 +89,59 @@ def properties_generator(self):
 
     def _create_items(self, items_spec):
         return self.create(items_spec)
+
+
+class SchemaDictFactory(object):
+
+    contributions = (
+        Contribution('type', src_prop_attr='value'),
+        Contribution('format'),
+        Contribution('properties', is_dict=True, dest_default={}),
+        Contribution('required', dest_default=[]),
+        Contribution('default'),
+        Contribution('nullable', dest_default=False),
+        Contribution('all_of', dest_prop_name='allOf', is_list=True, dest_default=[]),
+        Contribution('one_of', dest_prop_name='oneOf', is_list=True, dest_default=[]),
+        Contribution('additional_properties', dest_prop_name='additionalProperties', dest_default=True),
+        Contribution('min_items', dest_prop_name='minItems'),
+        Contribution('max_items', dest_prop_name='maxItems'),
+        Contribution('min_length', dest_prop_name='minLength'),
+        Contribution('max_length', dest_prop_name='maxLength'),
+        Contribution('pattern', src_prop_attr='pattern'),
+        Contribution('unique_items', dest_prop_name='uniqueItems', dest_default=False),
+        Contribution('minimum'),
+        Contribution('maximum'),
+        Contribution('multiple_of', dest_prop_name='multipleOf'),
+        Contribution('exclusive_minimum', dest_prop_name='exclusiveMinimum', dest_default=False),
+        Contribution('exclusive_maximum', dest_prop_name='exclusiveMaximum', dest_default=False),
+        Contribution('min_properties', dest_prop_name='minProperties'),
+        Contribution('max_properties', dest_prop_name='maxProperties'),
+    )
+
+    def create(self, schema):
+        schema_dict = {}
+        for contrib in self.contributions:
+            self._contribute(schema, schema_dict, contrib)
+        return schema_dict
+
+    def _contribute(self, schema, schema_dict, contrib):
+        def src_map(x):
+            return getattr(x, '__dict__')
+        src_val = getattr(schema, contrib.src_prop_name)
+
+        if src_val and contrib.src_prop_attr:
+            src_val = getattr(src_val, contrib.src_prop_attr)
+
+        if contrib.is_list:
+            src_val = list(map(src_map, src_val))
+        if contrib.is_dict:
+            src_val = dict(
+                (k, src_map(v))
+                for k, v in iteritems(src_val)
+            )
+
+        if src_val == contrib.dest_default:
+            return
+
+        dest_prop_name = contrib.dest_prop_name or contrib.src_prop_name
+        schema_dict[dest_prop_name] = src_val