Deserialized media types data kind

Author: p1c2u

openapi_core/casting/schemas/casters.py

@@ -1,4 +1,5 @@
 from typing import Any
+from typing import Dict
 from typing import Generic
 from typing import Iterable
 from typing import List
@@ -11,6 +12,7 @@
 from jsonschema_path import SchemaPath
 
 from openapi_core.casting.schemas.exceptions import CastError
+from openapi_core.deserializing.media_types.enums import DataKind
 from openapi_core.schema.schemas import get_properties
 from openapi_core.util import forcebool
 from openapi_core.validation.schemas.validators import SchemaValidator
@@ -27,7 +29,12 @@ def __init__(
         self.schema_validator = schema_validator
         self.schema_caster = schema_caster
 
-    def __call__(self, value: Any) -> Any:
+    def __call__(
+        self, 
+        value: Any, 
+        data_kind: DataKind = DataKind.STRINGLY,
+        property_data_kinds: Optional[Dict[str, DataKind]] = None
+    ) -> Any:
         return value
 
 
@@ -37,16 +44,22 @@ def __call__(self, value: Any) -> Any:
 class PrimitiveTypeCaster(Generic[PrimitiveType], PrimitiveCaster):
     primitive_type: Type[PrimitiveType] = NotImplemented
 
-    def __call__(self, value: Union[str, bytes]) -> Any:
+    def __call__(
+        self, 
+        value: Union[str, bytes], 
+        data_kind: DataKind = DataKind.STRINGLY,
+        property_data_kinds: Optional[Dict[str, DataKind]] = None
+    ) -> Any:
+        # STRINGLY: only coerce from str/bytes, return others unchanged
+        if data_kind == DataKind.STRINGLY:
+            if not isinstance(value, (str, bytes)):
+                return value
+        
         self.validate(value)
 
         return self.primitive_type(value)  # type: ignore [call-arg]
 
     def validate(self, value: Any) -> None:
-        # FIXME: don't cast data from media type deserializer
-        # See https://github.com/python-openapi/openapi-core/issues/706
-        # if not isinstance(value, (str, bytes)):
-        #     raise ValueError("should cast only from string or bytes")
         pass
 
 
@@ -61,19 +74,29 @@ class NumberCaster(PrimitiveTypeCaster[float]):
 class BooleanCaster(PrimitiveTypeCaster[bool]):
     primitive_type = bool
 
-    def __call__(self, value: Union[str, bytes]) -> Any:
+    def __call__(
+        self, 
+        value: Union[str, bytes], 
+        data_kind: DataKind = DataKind.STRINGLY,
+        property_data_kinds: Optional[Dict[str, DataKind]] = None
+    ) -> Any:
+        # STRINGLY: only coerce from str/bytes, return others unchanged
+        if data_kind == DataKind.STRINGLY:
+            if not isinstance(value, (str, bytes)):
+                return value
+        
         self.validate(value)
 
         return self.primitive_type(forcebool(value))
 
     def validate(self, value: Any) -> None:
-        super().validate(value)
-
-        # FIXME: don't cast data from media type deserializer
-        # See https://github.com/python-openapi/openapi-core/issues/706
+        # Already a boolean, accept it
         if isinstance(value, bool):
             return
 
+        if not isinstance(value, (str, bytes)):
+            return
+
         if value.lower() not in ["false", "true"]:
             raise ValueError("not a boolean format")
 
@@ -85,20 +108,36 @@ def items_caster(self) -> "SchemaCaster":
         items_schema = self.schema.get("items", SchemaPath.from_dict({}))
         return self.schema_caster.evolve(items_schema)
 
-    def __call__(self, value: Any) -> List[Any]:
+    def __call__(
+        self, 
+        value: Any, 
+        data_kind: DataKind = DataKind.STRINGLY,
+        property_data_kinds: Optional[Dict[str, DataKind]] = None
+    ) -> List[Any]:
         # str and bytes are not arrays according to the OpenAPI spec
         if isinstance(value, (str, bytes)) or not isinstance(value, Iterable):
             raise CastError(value, self.schema["type"])
 
+        items_schema = self.schema.getkey("items")
+        items_caster = self.schema_caster.evolve(items_schema)
+        # Array items don't have property names, pass empty policies dict
         try:
-            return list(map(self.items_caster.cast, value))
+            return list(
+                map(lambda item: items_caster.cast(item, data_kind=data_kind, property_data_kinds={}), value)
+            )
         except (ValueError, TypeError):
             raise CastError(value, self.schema["type"])
 
 
 class ObjectCaster(PrimitiveCaster):
-    def __call__(self, value: Any) -> Any:
-        return self._cast_proparties(value)
+    def __call__(
+        self, 
+        value: Any, 
+        data_kind: DataKind = DataKind.STRINGLY,
+        property_data_kinds: Optional[Dict[str, DataKind]] = None
+    ) -> Any:
+        return self._cast_proparties(value, schema_only=False, data_kind=data_kind,
+                                     property_data_kinds=property_data_kinds or {})
 
     def evolve(self, schema: SchemaPath) -> "ObjectCaster":
         cls = self.__class__
@@ -109,14 +148,24 @@ def evolve(self, schema: SchemaPath) -> "ObjectCaster":
             self.schema_caster.evolve(schema),
         )
 
-    def _cast_proparties(self, value: Any, schema_only: bool = False) -> Any:
+    def _cast_proparties(
+        self, 
+        value: Any, 
+        schema_only: bool = False, 
+        data_kind: DataKind = DataKind.STRINGLY,
+        property_data_kinds: Optional[Dict[str, DataKind]] = None
+    ) -> Any:
         if not isinstance(value, dict):
             raise CastError(value, self.schema["type"])
 
+        if property_data_kinds is None:
+            property_data_kinds = {}
+
         all_of_schemas = self.schema_validator.iter_all_of_schemas(value)
         for all_of_schema in all_of_schemas:
             all_of_properties = self.evolve(all_of_schema)._cast_proparties(
-                value, schema_only=True
+                value, schema_only=True, data_kind=data_kind,
+                property_data_kinds=property_data_kinds
             )
             value.update(all_of_properties)
 
@@ -125,8 +174,14 @@ def _cast_proparties(self, value: Any, schema_only: bool = False) -> Any:
                 prop_value = value[prop_name]
             except KeyError:
                 continue
+            
+            # Use property-specific policy if available, otherwise inherit parent policy
+            prop_data_kind = property_data_kinds.get(prop_name, data_kind)
+            
             value[prop_name] = self.schema_caster.evolve(prop_schema).cast(
-                prop_value
+                prop_value, 
+                data_kind=prop_data_kind,
+                property_data_kinds={}  # Policies don't cascade to nested objects
             )
 
         if schema_only:
@@ -150,7 +205,7 @@ def _cast_proparties(self, value: Any, schema_only: bool = False) -> Any:
             for prop_name, prop_value in value.items():
                 if prop_name in value:
                     continue
-                value[prop_name] = additional_prop_caster.cast(prop_value)
+                value[prop_name] = additional_prop_caster.cast(prop_value, data_kind=data_kind)
 
         return value
 
@@ -197,7 +252,16 @@ def __init__(
 
         self.types_caster = types_caster
 
-    def cast(self, value: Any) -> Any:
+    def cast(
+        self,
+        value: Any,
+        data_kind: DataKind = DataKind.STRINGLY,
+        property_data_kinds: Optional[Dict[str, DataKind]] = None,
+    ) -> Any:
+        # TYPED data: return value unchanged, no casting applied
+        if data_kind == DataKind.TYPED:
+            return value
+
         # skip casting for nullable in OpenAPI 3.0
         if value is None and self.schema.getkey("nullable", False):
             return value
@@ -210,7 +274,7 @@ def cast(self, value: Any) -> Any:
             return value
 
         try:
-            return type_caster(value)
+            return type_caster(value, data_kind=data_kind, property_data_kinds=property_data_kinds)
         except (ValueError, TypeError):
             raise CastError(value, schema_type)
 

openapi_core/casting/schemas/datatypes.py

@@ -1,6 +1,8 @@
 from typing import Any
+from typing import Dict
 from typing import Mapping
 from typing import Optional
+from typing import Tuple
 from xml.etree.ElementTree import ParseError
 
 from jsonschema_path import SchemaPath
@@ -11,9 +13,12 @@
 from openapi_core.deserializing.media_types.datatypes import (
     MediaTypeDeserializersDict,
 )
+from openapi_core.deserializing.media_types.enums import DataKind
 from openapi_core.deserializing.media_types.exceptions import (
     MediaTypeDeserializeError,
 )
+from openapi_core.deserializing.media_types.util import binary_loads
+from openapi_core.deserializing.media_types.util import json_loads
 from openapi_core.deserializing.styles.factories import (
     StyleDeserializersFactory,
 )
@@ -55,7 +60,21 @@ def get_deserializer_callable(
     ) -> DeserializerCallable:
         if mimetype in self.extra_media_type_deserializers:
             return self.extra_media_type_deserializers[mimetype]
-        return self.media_type_deserializers[mimetype]
+
+        # Exact match (for regular dicts / explicit registrations).
+        if mimetype in self.media_type_deserializers:
+            return self.media_type_deserializers[mimetype]
+
+        # Per RFC 6839, any media type ending with +json is JSON.
+        # Default to JSON parsing unless explicitly overridden above.
+        if mimetype.lower().endswith("+json"):
+            return json_loads
+
+        # Fallback for unknown media types.
+        try:
+            return self.media_type_deserializers[mimetype]
+        except KeyError:
+            return binary_loads
 
 
 class MediaTypeDeserializer:
@@ -75,7 +94,13 @@ def __init__(
         self.encoding = encoding
         self.parameters = parameters
 
-    def deserialize(self, value: bytes) -> Any:
+    def deserialize(self, value: bytes) -> Tuple[Any, Dict[str, DataKind]]:
+        """Deserialize value and return property data kinds.
+        
+        Returns:
+            Tuple of (deserialized_value, property_data_kinds)
+            where property_data_kinds maps property names to their DataKind.
+        """
         deserialized = self.media_types_deserializer.deserialize(
             self.mimetype, value, **self.parameters
         )
@@ -84,9 +109,10 @@ def deserialize(self, value: bytes) -> Any:
             self.mimetype != "application/x-www-form-urlencoded"
             and not self.mimetype.startswith("multipart")
         ):
-            return deserialized
+            # Non-form types: return empty data kind map
+            return deserialized, {}
 
-        # decode multipart request bodies
+        # decode multipart/form request bodies and build property data kinds
         return self.decode(deserialized)
 
     def evolve(
@@ -101,21 +127,32 @@ def evolve(
             schema=schema,
         )
 
-    def decode(self, location: Mapping[str, Any]) -> Mapping[str, Any]:
+    def decode(self, location: Mapping[str, Any]) -> Tuple[Mapping[str, Any], Dict[str, DataKind]]:
         # schema is required for multipart
         assert self.schema is not None
         properties = {}
+        property_data_kinds: Dict[str, DataKind] = {}
+        
         for prop_name, prop_schema in get_properties(self.schema).items():
             try:
                 properties[prop_name] = self.decode_property(
                     prop_name, prop_schema, location
                 )
+                
+                # Check if this property has JSON content type encoding
+                if self.encoding and prop_name in self.encoding:
+                    prop_encoding = self.encoding / prop_name
+                    prop_content_type = get_content_type(prop_schema, prop_encoding)
+                    # If encoded as JSON, mark as TYPED data
+                    if prop_content_type.lower() == "application/json" or prop_content_type.lower().endswith("+json"):
+                        property_data_kinds[prop_name] = DataKind.TYPED
+                        
             except KeyError:
                 if "default" not in prop_schema:
                     continue
                 properties[prop_name] = prop_schema["default"]
 
-        return properties
+        return properties, property_data_kinds
 
     def decode_property(
         self,
@@ -185,9 +222,18 @@ def decode_property_content_type(
         ):
             if isinstance(location, SuportsGetAll):
                 value = location.getall(prop_name)
-                return list(map(prop_deserializer.deserialize, value))
-            if isinstance(location, SuportsGetList):
+                deserialized_list = list(map(prop_deserializer.deserialize, value))
+                # Extract values from tuples if present
+                return [d[0] if isinstance(d, tuple) else d for d in deserialized_list]
+            elif isinstance(location, SuportsGetList):
                 value = location.getlist(prop_name)
-                return list(map(prop_deserializer.deserialize, value))
-
-        return prop_deserializer.deserialize(location[prop_name])
+                deserialized_list = list(map(prop_deserializer.deserialize, value))
+                # Extract values from tuples if present
+                return [d[0] if isinstance(d, tuple) else d for d in deserialized_list]
+        
+        # Deserialize the property value
+        deserialized = prop_deserializer.deserialize(location[prop_name])
+        # If it's a tuple (nested form/multipart), extract just the value
+        if isinstance(deserialized, tuple):
+            return deserialized[0]
+        return deserialized

openapi_core/deserializing/media_types/deserializers.py

@@ -0,0 +1,22 @@
+from enum import Enum
+from typing import Any
+from typing import Callable
+
+CasterCallable = Callable[[Any], Any]
+
+
+class DataKind(Enum):
+    """Kind/nature of deserialized data.
+
+    Describes whether data came from a typed deserializer that preserves 
+    runtime types, or from a string-based source that requires parsing.
+
+    Attributes:
+        TYPED: Data from a typed deserializer (JSON, MessagePack, etc.).
+            Values are already properly typed (int, float, bool, None, dict, list).
+        STRINGLY: Data from string-based encoding (forms, params, headers).
+            Values are strings/bytes that need parsing/coercion to match schema types.
+    """
+
+    TYPED = "typed"
+    STRINGLY = "stringly"