def test_transmute_mapping_subscripted(annotation, value):
annotation = resolve_supertype(annotation)
key_arg, value_arg = annotation.__args__
transmuted = transmute(annotation, value)
assert isinstance(transmuted, annotation.__origin__)
assert all(isinstance(x, get_origin(key_arg)) for x in transmuted.keys())
assert all(isinstance(x, get_origin(value_arg)) for x in transmuted.values())
def test_transmute_pandas(annotation, value, expected):
if annotation is objects.DFClass:
transmuted = objects.DFClass(value).df
else:
transmuted = transmute(annotation, value)
assert isinstance(transmuted, annotation)
assert transmuted == expected if expected is None else expected.equals(transmuted)
def test_transmute_nested_sequence():
transmuted = transmute(objects.NestedSeq, {"datum": [{"foo": "bar"}]})
assert isinstance(transmuted, objects.NestedSeq)
assert all(isinstance(x, objects.Data) for x in transmuted.datum)
def test_transmute_optional(annotation, value, expected):
transmuted = transmute(annotation, value)
assert transmuted == expected
def test_transmute_tuple_subscripted(annotation, value, expected):
transmuted = transmute(annotation, value)
assert transmuted == expected
def test_transmute_collections_subscripted(annotation, value):
arg = annotation.__args__[0]
transmuted = transmute(annotation, value)
assert isinstance(transmuted, annotation.__origin__) and all(
isinstance(x, arg) for x in transmuted
)
def test_transmute_nested_constrained(anno, val, expected):
c = transmute(anno, val)
assert c == expected
def test_strict_anno_fails(anno, val):
with pytest.raises(ConstraintValueError):
transmute(anno, val)
def test_transmute_collection_metas(annotation, value, expected):
transmuted = transmute(annotation, value)
assert transmuted == expected
def test_transmute_newtype(annotation, value):
transmuted = transmute(annotation, value)
assert isinstance(transmuted, annotation.__supertype__)
def test_invalid_literal():
with pytest.raises(TypeError):
transmute(Literal[datetime.date.today()], [1])
def test_transmute_literal_invalid(annotation, value):
with pytest.raises(ConstraintValueError):
transmute(annotation, value)
def test_transmute_simple(annotation, value, expected):
transmuted = transmute(annotation, value)
t = dict if istypeddict(annotation) else annotation
assert isinstance(transmuted, t)
assert transmuted == expected
def test_union_transmute(annotation, value, expected, t):
transmuted = transmute(annotation, value)
assert transmuted == expected
assert isinstance(transmuted, t)
def test_tagged_union_transmute(annotation, value, expected):
transmuted = transmute(annotation, value)
assert isinstance(transmuted, annotation)
assert transmuted == expected
def test_no_transmuter(val):
class NoTransmuter:
def __init__(self, x):
self.x = x
assert transmute(NoTransmuter, val).x == val
def test_cast_constrained_invalid(type, value):
with pytest.raises(ConstraintValueError):
transmute(type, value)
def test_default_none():
transmuted = transmute(objects.DefaultNone, {})
assert transmuted.none is None
def test_strict_anno_passes(anno, val):
assert transmute(anno, val) == val
def test_default_ellipsis():
transmuted = transmute(objects.DefaultEllipsis, {})
assert transmuted.ellipsis is ...
def test_recursive_transmute(annotation, value, expected):
transmuted = transmute(annotation, value)
assert isinstance(transmuted, annotation)
assert transmuted == expected
def test_transmute_supscripted(annotation, value, expected):
assert transmute(annotation, value) == expected
