def test_structure_hook_func(): """ testing the hook_func method """ converter = Converter() def can_handle(cls): return cls.__name__.startswith("F") def handle(obj, cls): return "hi" class Foo(object): pass class Bar(object): pass converter.register_structure_hook_func(can_handle, handle) assert converter.structure(10, Foo) == "hi" with raises(ValueError): converter.structure(10, Bar)
def test_optional_field_roundtrip(cl_and_vals): """ Classes with optional fields can be unstructured and structured. """ converter = Converter() cl, vals = cl_and_vals @attr.s class C(object): a = attr.ib(type=Optional[cl]) inst = C(a=cl(*vals)) assert inst == converter.structure(converter.unstructure(inst), C) inst = C(a=None) unstructured = converter.unstructure(inst) assert inst == converter.structure(unstructured, C)
def test_union_field_roundtrip(cl_and_vals_a, cl_and_vals_b, strat): """ Classes with union fields can be unstructured and structured. """ converter = Converter(unstruct_strat=strat) cl_a, vals_a = cl_and_vals_a cl_b, _ = cl_and_vals_b a_field_names = {a.name for a in fields(cl_a)} b_field_names = {a.name for a in fields(cl_b)} assume(a_field_names) assume(b_field_names) common_names = a_field_names & b_field_names assume(len(a_field_names) > len(common_names)) @attr.s class C(object): a = attr.ib(type=Union[cl_a, cl_b]) inst = C(a=cl_a(*vals_a)) if strat is UnstructureStrategy.AS_DICT: unstructured = converter.unstructure(inst) assert inst == converter.structure( converter.unstructure(unstructured), C ) else: # Our disambiguation functions only support dictionaries for now. with pytest.raises(ValueError): converter.structure(converter.unstructure(inst), C) def handler(obj, _): return converter.structure(obj, cl_a) converter.register_structure_hook(Union[cl_a, cl_b], handler) unstructured = converter.unstructure(inst) assert inst == converter.structure(unstructured, C)
def test_310_optional_field_roundtrip(cl_and_vals): """ Classes with optional fields can be unstructured and structured. """ converter = Converter() cl, vals = cl_and_vals @define class C: a: cl | None inst = C(a=cl(*vals)) assert inst == converter.structure(converter.unstructure(inst), C) inst = C(a=None) unstructured = converter.unstructure(inst) assert inst == converter.structure(unstructured, C)
from twisted.logger import Logger from ims.ext.json import dateTimeAsRFC3339Text, rfc3339TextAsDateTime __all__ = () log = Logger() class JSONCodecError(Exception): """ Error while serializing or deserializing JSON data. """ converter = Converter() jsonSerialize = converter.unstructure jsonDeserialize = converter.structure registerSerializer = converter.register_unstructure_hook registerDeserializer = converter.register_structure_hook # Serialization hooks registerSerializer(DateTime, dateTimeAsRFC3339Text) # Deserialization hooks def deserializeDateTime(obj: str, cl: Type) -> DateTime: assert cl is DateTime, (cl, obj)
def test_able_to_structure_generics(converter: Converter, t, t2, result): res = converter.structure(asdict(result), TClass[t, t2]) assert res == result
from enum import Enum, IntEnum, unique from typing import List, Optional import attr from aiohttp import ClientSession from cattr import Converter from pendulum import DateTime, from_timestamp from ujson import dumps, loads from pyrseia import create_client, rpc from pyrseia.aiohttp import aiohttp_client_adapter from pyrseia.wire import Call PRODUCTION_URL = "https://buy.itunes.apple.com/verifyReceipt" SANDBOX_URL = "https://sandbox.itunes.apple.com/verifyReceipt" APP_STORE_CONVERTER = Converter() APP_STORE_CONVERTER.register_structure_hook( DateTime, lambda m, _: from_timestamp(float(m) / 1000) ) @attr.s(slots=True, frozen=True) class ResponseBody: """This structure is called 'responseBody' by Apple.""" @unique class Environment(str, Enum): SANDBOX = "Sandbox" PRODUCTION = "Production"
def create_cattrs_converter(): converter = Converter() converter.register_structure_hook(bool, _structure_bool) converter.register_structure_hook(string_type, _structure_string) converter.register_structure_hook(Model, _structure_schematics) converter.register_structure_hook(BaseType, _structure_basetype) converter.register_structure_hook(datetime, _structure_datetime) converter.register_unstructure_hook(Model, _unstructure_schematics) converter.register_unstructure_hook(datetime, _unstructure_datetime) converter.register_unstructure_hook(BaseType, _unstructure_basetype) return converter
else: import pickle pickle_loads = f.partial(pickle.loads, encoding='bytes') pickle_load = f.partial(pickle.load, encoding='bytes') pickle_dumps = f.partial(pickle.dumps, protocol=2) pickle_dump = f.partial(pickle.dump, protocol=2) def u2c(value): """Convert underscore string to capitalized string.""" # Make a list of capitalized words and underscores to be preserved capitalized_words = [w.capitalize() if w else '_' for w in value.split('_')] return "".join(capitalized_words) CUSTOM_CVT = Converter() CUSTOM_CVT.register_unstructure_hook( np.ndarray, lambda a: dict(dtype=a.dtype.name, data=a.tobytes(), shape=list(a.shape))) CUSTOM_CVT.register_structure_hook( np.ndarray, lambda a, _: np.frombuffer(a['data'], dtype=a['dtype']).reshape(tuple(a['shape']))) def to_dict(obj): """Convert object to dict""" global CUSTOM_CVT return CUSTOM_CVT.unstructure(obj) def from_dict(d, cls, compatible=True):
def converter(): return Converter()
def test_structuring_primitives(primitive_and_type): """Test just structuring a primitive value.""" converter = Converter() val, t = primitive_and_type assert converter.structure(val, t) == val assert converter.structure(val, Any) == val
def test_structuring_enums(data, enum): """Test structuring enums by their values.""" converter = Converter() val = data.draw(sampled_from(list(enum))) assert converter.structure(val.value, enum) == val
def setup_cattrs(converter: cattr.Converter) -> None: # mypy cannot infer :( def unstructure_snowflake(struct: Snowflake) -> str: return str(struct) converter.register_unstructure_hook(Snowflake, unstructure_snowflake)
from schematics.types import DateTimeType datetime_type = DateTimeType() def _structure_datetime(data, cls): if not data: raise ValueError("datetime is empty") return datetime_type.to_native(data) def _unstructure_datetime(data): return data.isoformat() converter = Converter() converter.register_structure_hook(datetime, _structure_datetime) converter.register_unstructure_hook(datetime, _unstructure_datetime) def validate_len(instance, attribute, value): if len(value) > 100: raise ValueError("val should <= 100") @attr.s class Artist2: name = attr.ib(type=str, validator=validate_len) @attr.s