Media type encoding support

Author: p1c2u

Diff for: openapi_core/deserializing/media_types/deserializers.py

@@ -1,33 +1,135 @@
 import warnings
 from typing import Any
+from typing import Dict
 from typing import Optional
+from typing import cast
 from xml.etree.ElementTree import ParseError
 
+from jsonschema_path import SchemaPath
+
 from openapi_core.deserializing.media_types.datatypes import (
     DeserializerCallable,
 )
+from openapi_core.deserializing.media_types.datatypes import (
+    MediaTypeDeserializersDict,
+)
 from openapi_core.deserializing.media_types.exceptions import (
     MediaTypeDeserializeError,
 )
+from openapi_core.schema.encodings import get_encoding_default_content_type
+
+
+class ContentTypesDeserializer:
+    def __init__(
+        self,
+        media_type_deserializers: Optional[MediaTypeDeserializersDict] = None,
+        extra_media_type_deserializers: Optional[
+            MediaTypeDeserializersDict
+        ] = None,
+    ):
+        if media_type_deserializers is None:
+            media_type_deserializers = {}
+        self.media_type_deserializers = media_type_deserializers
+        if extra_media_type_deserializers is None:
+            extra_media_type_deserializers = {}
+        self.extra_media_type_deserializers = extra_media_type_deserializers
+
+    def deserialize(self, mimetype: str, value: Any, **parameters: str) -> Any:
+        deserializer_callable = self.get_deserializer_callable(mimetype)
+        if deserializer_callable is None:
+            warnings.warn(f"Unsupported {mimetype} mimetype")
+            return value
+
+        try:
+            return deserializer_callable(value, **parameters)
+        except (ParseError, ValueError, TypeError, AttributeError):
+            raise MediaTypeDeserializeError(mimetype, value)
+
+    def get_deserializer_callable(
+        self,
+        mimetype: str,
+    ) -> Optional[DeserializerCallable]:
+        if mimetype in self.extra_media_type_deserializers:
+            return self.extra_media_type_deserializers[mimetype]
+        return self.media_type_deserializers.get(mimetype)
 
 
-class CallableMediaTypeDeserializer:
+class MediaTypeDeserializer:
     def __init__(
         self,
         mimetype: str,
-        deserializer_callable: Optional[DeserializerCallable] = None,
+        content_types_deserializers: ContentTypesDeserializer,
+        schema: Optional[SchemaPath] = None,
+        encoding: Optional[SchemaPath] = None,
         **parameters: str,
     ):
+        self.schema = schema
         self.mimetype = mimetype
-        self.deserializer_callable = deserializer_callable
+        self.content_types_deserializers = content_types_deserializers
+        self.encoding = encoding
         self.parameters = parameters
 
     def deserialize(self, value: Any) -> Any:
-        if self.deserializer_callable is None:
-            warnings.warn(f"Unsupported {self.mimetype} mimetype")
-            return value
+        deserialized = self.content_types_deserializers.deserialize(
+            self.mimetype, value, **self.parameters
+        )
 
-        try:
-            return self.deserializer_callable(value, **self.parameters)
-        except (ParseError, ValueError, TypeError, AttributeError):
-            raise MediaTypeDeserializeError(self.mimetype, value)
+        if (
+            self.mimetype != "application/x-www-form-urlencoded"
+            and not self.mimetype.startswith("multipart")
+        ):
+            return deserialized
+
+        return self.decode(deserialized)
+
+    def evolve(
+        self, mimetype: str, schema: Optional[SchemaPath]
+    ) -> "MediaTypeDeserializer":
+        cls = self.__class__
+
+        return cls(
+            mimetype,
+            self.content_types_deserializers,
+            schema=schema,
+        )
+
+    def decode(self, value: Dict[str, Any]) -> Dict[str, Any]:
+        return {
+            prop_name: self.decode_property(prop_name, prop_value)
+            for prop_name, prop_value in value.items()
+        }
+
+    def decode_property(self, prop_name: str, value: Any) -> Any:
+        # schema is required for multipart
+        assert self.schema
+        schema_props = self.schema.get("properties")
+        prop_schema = None
+        if schema_props is not None and prop_name in schema_props:
+            prop_schema = cast(
+                Optional[SchemaPath],
+                schema_props.get(prop_name),
+            )
+        prop_content_type = self.get_property_content_type(
+            prop_name, prop_schema
+        )
+        prop_deserializer = self.evolve(
+            prop_content_type,
+            prop_schema,
+        )
+        return prop_deserializer.deserialize(value)
+
+    def get_property_content_type(
+        self, prop_name: str, prop_schema: Optional[SchemaPath] = None
+    ) -> str:
+        if self.encoding is None:
+            return get_encoding_default_content_type(prop_schema)
+
+        if prop_name not in self.encoding:
+            return get_encoding_default_content_type(prop_schema)
+
+        prep_encoding = self.encoding.get(prop_name)
+        prop_content_type = prep_encoding.getkey("contentType")
+        if prop_content_type is None:
+            return get_encoding_default_content_type(prop_schema)
+
+        return cast(str, prop_content_type)

Diff for: openapi_core/deserializing/media_types/factories.py

@@ -1,14 +1,19 @@
 from typing import Mapping
 from typing import Optional
 
+from jsonschema_path import SchemaPath
+
 from openapi_core.deserializing.media_types.datatypes import (
     DeserializerCallable,
 )
 from openapi_core.deserializing.media_types.datatypes import (
     MediaTypeDeserializersDict,
 )
 from openapi_core.deserializing.media_types.deserializers import (
-    CallableMediaTypeDeserializer,
+    ContentTypesDeserializer,
+)
+from openapi_core.deserializing.media_types.deserializers import (
+    MediaTypeDeserializer,
 )
 
 
@@ -24,29 +29,26 @@ def __init__(
     def create(
         self,
         mimetype: str,
+        schema: Optional[SchemaPath] = None,
         parameters: Optional[Mapping[str, str]] = None,
+        encoding: Optional[SchemaPath] = None,
         extra_media_type_deserializers: Optional[
             MediaTypeDeserializersDict
         ] = None,
-    ) -> CallableMediaTypeDeserializer:
+    ) -> MediaTypeDeserializer:
         if parameters is None:
             parameters = {}
         if extra_media_type_deserializers is None:
             extra_media_type_deserializers = {}
-        deserialize_callable = self.get_deserializer_callable(
-            mimetype,
-            extra_media_type_deserializers=extra_media_type_deserializers,
+        content_types_deserializer = ContentTypesDeserializer(
+            self.media_type_deserializers,
+            extra_media_type_deserializers,
         )
 
-        return CallableMediaTypeDeserializer(
-            mimetype, deserialize_callable, **parameters
+        return MediaTypeDeserializer(
+            mimetype,
+            content_types_deserializer,
+            schema=schema,
+            encoding=encoding,
+            **parameters,
         )
-
-    def get_deserializer_callable(
-        self,
-        mimetype: str,
-        extra_media_type_deserializers: MediaTypeDeserializersDict,
-    ) -> Optional[DeserializerCallable]:
-        if mimetype in extra_media_type_deserializers:
-            return extra_media_type_deserializers[mimetype]
-        return self.media_type_deserializers.get(mimetype)

Diff for: openapi_core/schema/encodings.py

@@ -0,0 +1,27 @@
+from typing import Optional
+
+from jsonschema_path import SchemaPath
+
+
+def get_encoding_default_content_type(
+    prop_schema: Optional[SchemaPath],
+) -> str:
+    if prop_schema is None:
+        return "text/plain"
+
+    prop_type = prop_schema.getkey("type")
+    if prop_type is None:
+        return "text/plain"
+
+    prop_format = prop_schema.getkey("format")
+    if prop_type == "string" and prop_format in ["binary", "base64"]:
+        return "application/octet-stream"
+
+    if prop_type == "object":
+        return "application/json"
+
+    if prop_type == "array":
+        prop_items = prop_schema / "items"
+        return get_encoding_default_content_type(prop_items)
+
+    return "text/plain"

Diff for: openapi_core/validation/validators.py

@@ -99,12 +99,22 @@ def _find_media_type(
         return finder.find(mimetype)
 
     def _deserialise_media_type(
-        self, mimetype: str, parameters: Mapping[str, str], value: Any
+        self,
+        media_type: SchemaPath,
+        mimetype: str,
+        parameters: Mapping[str, str],
+        value: Any,
     ) -> Any:
+        schema = media_type.get("schema")
+        encoding = None
+        if "encoding" in media_type:
+            encoding = media_type.get("encoding")
         deserializer = self.media_type_deserializers_factory.create(
             mimetype,
-            extra_media_type_deserializers=self.extra_media_type_deserializers,
+            schema=schema,
             parameters=parameters,
+            encoding=encoding,
+            extra_media_type_deserializers=self.extra_media_type_deserializers,
         )
         return deserializer.deserialize(value)
 
@@ -214,7 +224,9 @@ def _convert_content_schema_value_and_schema(
         mime_type, parameters, media_type = self._find_media_type(
             content, mimetype
         )
-        deserialised = self._deserialise_media_type(mime_type, parameters, raw)
+        deserialised = self._deserialise_media_type(
+            media_type, mime_type, parameters, raw
+        )
         casted = self._cast(media_type, deserialised)
 
         if "schema" not in media_type:

Diff for: tests/unit/deserializing/test_media_types_deserializers.py

@@ -1,6 +1,7 @@
 from xml.etree.ElementTree import Element
 
 import pytest
+from jsonschema_path import SchemaPath
 
 from openapi_core.deserializing.exceptions import DeserializeError
 from openapi_core.deserializing.media_types import media_type_deserializers
@@ -14,6 +15,8 @@ class TestMediaTypeDeserializer:
     def deserializer_factory(self):
         def create_deserializer(
             media_type,
+            schema=None,
+            encoding=None,
             parameters=None,
             media_type_deserializers=media_type_deserializers,
             extra_media_type_deserializers=None,
@@ -22,7 +25,9 @@ def create_deserializer(
                 media_type_deserializers,
             ).create(
                 media_type,
+                schema=schema,
                 parameters=parameters,
+                encoding=encoding,
                 extra_media_type_deserializers=extra_media_type_deserializers,
             )
 
@@ -148,7 +153,16 @@ def test_urlencoded_form_empty(self, deserializer_factory):
 
     def test_urlencoded_form_simple(self, deserializer_factory):
         mimetype = "application/x-www-form-urlencoded"
-        deserializer = deserializer_factory(mimetype)
+        schema_dict = {
+            "type": "object",
+            "properties": {
+                "param1": {
+                    "type": "string",
+                },
+            },
+        }
+        schema = SchemaPath.from_dict(schema_dict)
+        deserializer = deserializer_factory(mimetype, schema=schema)
         value = "param1=test"
 
         result = deserializer.deserialize(value)
@@ -166,7 +180,17 @@ def test_data_form_empty(self, deserializer_factory, value):
 
     def test_data_form_simple(self, deserializer_factory):
         mimetype = "multipart/form-data"
-        deserializer = deserializer_factory(mimetype)
+        schema_dict = {
+            "type": "object",
+            "properties": {
+                "param1": {
+                    "type": "string",
+                    "format": "binary",
+                },
+            },
+        }
+        schema = SchemaPath.from_dict(schema_dict)
+        deserializer = deserializer_factory(mimetype, schema=schema)
         value = (
             b'Content-Type: multipart/form-data; boundary="'
             b'===============2872712225071193122=="\n'