def to_raw_deserializer(func: Callable) -> Converter:
types = get_type_hints(func, include_extras=True)
if "return" not in types:
raise TypeError("Return must be annotated")
sig = signature(func)
fields: List[MakeDataclassField] = []
kwargs_param = None
for name, param in sig.parameters.items():
if param.kind == Parameter.POSITIONAL_ONLY: # pragma: no cover
raise TypeError("Forbidden positional-only parameter")
if param.kind == Parameter.VAR_POSITIONAL:
raise TypeError("Forbidden variadic positional parameter")
if param.kind == Parameter.VAR_KEYWORD:
from apischema import properties
field_ = field(default_factory=dict, metadata=properties)
type_ = Mapping[str, types.get(name, Any)] # type: ignore
fields.append((name, type_, field_)) # type: ignore
kwargs_param = name
continue
default = param.default if param.default is not Parameter.empty else MISSING
try:
fields.append((name, types[name], field(default=default)))
except KeyError:
raise TypeError("All parameters must be annotated")
def converter(obj):
kwargs = {f: getattr(obj, f) for f, _, _ in fields}
if kwargs_param in kwargs:
kwargs.update(kwargs.pop(kwargs_param))
return func(**kwargs)
cls = with_fields_set(make_dataclass(to_camel_case(func.__name__), fields))
converter.__annotations__ = {"obj": cls, "return": types["return"]}
return converter
def merge_into(self, base_schema: Dict[str, Any]):
if self.deprecated:
base_schema["deprecated"] = bool(self.deprecated)
for k in ("title", "description", "examples", "format"):
if getattr(self, k) is not None:
base_schema[k] = getattr(self, k)
for k in ("media_type", "encoding"):
if getattr(self, k) is not None:
base_schema[to_camel_case("content_" + k)] = getattr(self, k)
if self.default is not None:
base_schema["default"] = self.default()
def test_to_camel_case():
assert to_camel_case("min_length") == "minLength"
def _as_str(cls: Type, **kwargs):
from apischema import schema
str_type = schema(**kwargs)(NewType(to_camel_case(cls.__name__), str))
deserializer(cls, str_type, cls)
serializer(str, cls, str_type)