def test_benchmarks_translate_from_class(benchmark, mod):
benchmark.group = "Translate from Arbitrary Class"
benchmark.name = mod
translate = _MODS[mod].translate_from
instance = typic.transmute(marsh.Model, VALID_RAW)
valid, data = benchmark(translate, instance)
assert valid, data
def test_benchmarks_serialize_valid_data(benchmark, mod):
benchmark.group = "Serialize Valid Data"
benchmark.name = mod
serialize = _MODS[mod].tojson
model = _MODS[mod].Model
instance = (model(**VALID_RAW) if mod == "pydantic" else typic.transmute(
model, VALID_RAW))
valid, data = benchmark(serialize, instance)
assert valid, data
def _response_to_return(self, response: Response):
return_annotation = self.dependant.signature.return_annotation
if return_annotation is inspect.Parameter.empty or return_annotation is Response:
return response
elif return_annotation is None:
return None
elif return_annotation is str:
return response.text
elif return_annotation is bytes:
return response.content
else:
try:
return typic.transmute(return_annotation, response.json())
except ValueError:
try:
return typic.transmute(return_annotation, response.text)
except ValueError:
pass
return response
def test_benchmarks_serialize_valid_data(benchmark, mod):
benchmark.group = "Serialize Valid Data"
benchmark.name = mod
serialize = _MODS[mod].tojson
model = _MODS[mod].Model
if mod == "pydantic":
instance = model(**VALID_RAW)
elif mod == "apischema":
_, instance = _MODS[mod].deserialize(deepcopy(VALID_RAW))
else:
instance = typic.transmute(model, VALID_RAW)
valid, data = benchmark(serialize, instance)
assert valid, data
def test_transmute_excluded():
@dataclasses.dataclass
class Foo:
__serde_flags__ = typic.flags(exclude=("excluded", ))
bar: str = None
excluded: bool = True
@dataclasses.dataclass
class Bar:
bar: str = None
excluded: bool = False
assert typic.transmute(Bar, Foo()) == Bar()
def test_benchmarks_serialize_invalid_data(benchmark, mod):
benchmark.group = "Serialize Invalid Data"
benchmark.name = mod
serialize = _MODS[mod].tojson
model = _MODS[mod].Model
instance = (model(**VALID_RAW) if mod == "pydantic" else typic.transmute(
model, VALID_RAW))
instance.skills.append(NotASkill())
valid, data = benchmark(serialize, instance)
# Marshmallow implicitly filters invalid data, and pydantic doesn't care at all.
if mod in {"marshmallow", "pydantic"}:
assert valid, data
else:
assert not valid, data
def test_transmute_pandas_union():
import pandas
transmuted = typic.transmute(Union[pandas.DataFrame, pandas.Series], {})
assert isinstance(transmuted, pandas.DataFrame)
def test_transmute_pandas_dataframe():
import pandas
transmuted = typic.transmute(pandas.DataFrame, {})
assert isinstance(transmuted, pandas.DataFrame)
def test_transmute_pandas_series():
import pandas
transmuted = typic.transmute(pandas.Series, [])
assert isinstance(transmuted, pandas.Series)
def transmute(instance):
return True, typic.transmute(Model, instance)
def deserialize(data):
try:
return True, typic.transmute(Model, data)
except (TypeError, ValueError) as err:
return False, err
@typic.klass
class Klass:
attr: str
class Other:
def __init__(self, attr: str):
self.attr = attr
if __name__ == "__main__":
Klass(attr="foo")
Klass("foo")
Klass.transmute("foo")
Klass.validate({"attr": "foo"})
Klass("foo").primitive()
Klass("foo").primitive(lazy=True)
Klass("foo").tojson()
Klass("foo").tojson(indent=0)
Klass("foo").tojson(ensure_ascii=False)
typic.primitive(Klass("foo"))
k: Klass = typic.transmute(Klass, "foo")
v = typic.validate(Klass, {"attr": "foo"})
j: str = typic.tojson(Klass("foo"))
o: Other = Klass("foo").translate(Other)
fields = [*Klass("foo").iterate()]
iterfields = [*Klass("foo")]
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
import dataclasses
import json
import pathlib
from copy import deepcopy
import pytest
import typic
from benchmark.models import apisch, drf, functional, klass, marsh, protocol, pyd
THIS_DIR = pathlib.Path(__file__).parent.resolve()
VALID_RAW = json.loads((THIS_DIR / "valid.json").read_text())
VALID_DESER = dataclasses.asdict(typic.transmute(functional.Model, VALID_RAW))
INVALID = json.loads((THIS_DIR / "invalid.json").read_text())
_MODS = {
"typic-object-api": klass,
"typic-protocol-api": protocol,
"typic-functional-api": functional,
"pydantic": pyd,
"marshmallow": marsh,
"djangorestframework": drf,
"apischema": apisch,
}
_TRANSLATE_FROM_MODS = {
"typic-object-api": klass,
"typic-protocol-api": protocol,
def test_pep_604():
assert typic.transmute(
objects.Pep604, {"union": {"key": 1, "field": "blah"}}
) == objects.Pep604(union=objects.DFoo("blah"))
assert objects.pep604({"key": 2, "field": "blah"}) == objects.DBar(b"blah")
def test_pep_585():
assert typic.transmute(objects.Pep585, {"data": {"foo": "1"}}) == objects.Pep585(
data={"foo": 1}
)
assert objects.pep585({"foo": "1"}) == {"foo": 1}