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}