Unmarshallers refactor

Author: p1c2u

openapi_core/schema/schemas.py

@@ -1,7 +1,12 @@
+from collections import namedtuple
 from typing import Dict
 from typing import Optional
 
 from openapi_core.unmarshalling.schemas.formatters import Formatter
 
 CustomFormattersDict = Dict[str, Formatter]
 FormattersDict = Dict[Optional[str], Formatter]
+SchemaUnmarshaller = namedtuple(
+    "SchemaUnmarshaller",
+    ["schema", "unmarshaller"],
+)

openapi_core/unmarshalling/schemas/datatypes.py

@@ -102,19 +102,11 @@ def create(
         if schema_type in self.COMPLEX_UNMARSHALLERS:
             complex_klass = self.COMPLEX_UNMARSHALLERS[schema_type]
             return complex_klass(
-                schema, validator, formatter, self, context=self.context
+                schema, validator, self, formatter, context=self.context
             )
 
         klass = self.UNMARSHALLERS[schema_type]
-        return klass(schema, validator, formatter)
-
-    def get_formatter(
-        self, type_format: str, default_formatters: FormattersDict
-    ) -> Optional[Formatter]:
-        try:
-            return self.custom_formatters[type_format]
-        except KeyError:
-            return default_formatters.get(type_format)
+        return klass(schema, validator, self, formatter)
 
     def get_validator(self, schema: Spec) -> Validator:
         resolver = schema.accessor.resolver  # type: ignore

openapi_core/unmarshalling/schemas/factories.py

@@ -8,20 +8,20 @@ class Formatter:
     def validate(self, value: Any) -> bool:
         return True
 
-    def unmarshal(self, value: Any) -> Any:
+    def format(self, value: Any) -> Any:
         return value
 
     @classmethod
     def from_callables(
         cls,
-        validate: Optional[Callable[[Any], Any]] = None,
-        unmarshal: Optional[Callable[[Any], Any]] = None,
+        validate_callable: Optional[Callable[[Any], Any]] = None,
+        format_callable: Optional[Callable[[Any], Any]] = None,
     ) -> "Formatter":
         attrs = {}
-        if validate is not None:
-            attrs["validate"] = staticmethod(validate)
-        if unmarshal is not None:
-            attrs["unmarshal"] = staticmethod(unmarshal)
+        if validate_callable is not None:
+            attrs["validate"] = staticmethod(validate_callable)
+        if format_callable is not None:
+            attrs["format"] = staticmethod(format_callable)
 
         klass: Type[Formatter] = type("Formatter", (cls,), attrs)
         return klass()