def test_convert(models_generator: MetadataGenerator):
data = {
"dict_field": {},
"another_dict_field": {
"test_dict_field_a": 1,
"test_dict_field_b": "a"
},
"another_dict_field_2": {
"test_dict_field_a": 1
},
"another_dict_field_3": {
"test_dict_field_a": 1,
"test_dict_field_b": 2
},
"int_field": 1,
"not": False
}
meta = models_generator._convert(data)
assert meta == {
"dict_field": DDict(Unknown),
"another_dict_field": DDict(DUnion(int, StringLiteral({"a"}))),
"another_dict_field_2": DDict(int),
"another_dict_field_3": DDict(int),
"int_field": int,
"not": bool
}
def test_hash_string():
a = {'a': int}
b = {'b': int}
c = {'a': float}
assert len(set(map(get_hash_string, (a, b, c)))) == 3
union = DUnion(str, float)
h1 = union.to_hash_string()
union.replace(complex, index=0)
h2 = union.to_hash_string()
assert h1 != h2, f"{h1}, {h2}"
not_: bool = attr.ib({field_meta('not')})
one_day: int = attr.ib({field_meta('1day')})
den_nedeli: str = attr.ib({field_meta('день_недели')})
baz: Optional[List[List[str]]] = attr.ib(factory=list)
bar: Optional[IntString] = attr.ib(default=None)
asdfg: Optional[int] = attr.ib(default=None)
""")
},
"converters": {
"model": ("Test", {
"a": int,
"b": IntString,
"c": DOptional(FloatString),
"d": DList(DList(DList(IntString))),
"e": DDict(IntString),
"u": DUnion(DDict(IntString), DList(DList(IntString))),
}),
"generated": trim("""
import attr
from json_to_models.dynamic_typing import FloatString, IntString
from json_to_models.models import ClassType
from json_to_models.models.string_converters import convert_strings
from typing import Dict, List, Optional, Union
@attr.s
@convert_strings(['b', 'c#O.S', 'd#L.L.L.S', 'e#D.S'], class_type=ClassType.Attrs)
class Test:
a: int = attr.ib()
b: IntString = attr.ib()
d: List[List[List[IntString]]] = attr.ib()
FloatString, IntString, Null,
StringLiteral, Unknown)
from json_to_models.generator import MetadataGenerator
# JSON data | MetaData
test_data = [
pytest.param(1.0, float, id="float"),
pytest.param(1, int, id="int"),
pytest.param(True, bool, id="bool"),
pytest.param("abc", StringLiteral({"abc"}), id="str"),
pytest.param(None, Null, id="null"),
pytest.param([], DList(Unknown), id="list_empty"),
pytest.param([1], DList(int), id="list_single"),
pytest.param([*range(100)], DList(int), id="list_single_type"),
pytest.param([1, "a", 2, "c"],
DList(DUnion(int, StringLiteral({'a', 'c'}))),
id="list_multi"),
pytest.param("1", IntString, id="int_str"),
pytest.param("1.0", FloatString, id="float_str"),
pytest.param("true", BooleanString, id="bool_str"),
pytest.param({
"test_dict_field_a": 1,
"test_dict_field_b": "a"
},
DDict(DUnion(int, StringLiteral({"a"}))),
id="simple_dict"),
pytest.param({}, DDict(Unknown), id="empty_dict")
]
test_dict = {param.id: param.values[0] for param in test_data}
test_dict_meta = {param.id: param.values[1] for param in test_data}
import pytest
from json_to_models.dynamic_typing import DOptional, DUnion, FloatString, IntString
from json_to_models.generator import MetadataGenerator
# List of fields sets | result field set
test_data = [
pytest.param(
[{'a': int}, {'a': int, 'b': int}],
{'a': int, 'b': DOptional(int)},
id="optional_fields"
),
pytest.param(
[{'a': int}, {'a': float}],
{'a': DUnion(int, float)},
id="union"
),
pytest.param(
[{'a': DUnion(str, bool)}, {'a': float}],
{'a': DUnion(str, bool, float)},
id="merge_unions"
),
pytest.param(
[{'a': DUnion(str, bool)}, {'a': DUnion(int, float)}],
{'a': DUnion(str, bool, int, float)},
id="merge_unions2"
),
pytest.param(
[{'a': int}, {}, {'a': int}, {}],
{'a': DOptional(int)},
def test_dunion_creation(value, expected):
result = DUnion(*value)
assert result == expected
from builtins import complex
import pytest
from json_to_models.dynamic_typing import DUnion, StringLiteral, get_hash_string
# *args | MetaData
test_dunion = [
pytest.param([int, int], DUnion(int), id="unique_types"),
pytest.param([int, DUnion(int)], DUnion(int), id="nested_union_&_merge"),
pytest.param([str, DUnion(int, DUnion(float, complex))],
DUnion(int, float, complex, str),
id="complex_merge"),
pytest.param([str, StringLiteral({'a'})],
DUnion(str),
id="str_literal_to_string"),
pytest.param(
[StringLiteral({'b'}), StringLiteral({'a'})],
DUnion(StringLiteral({'a', 'b'})),
id="str_literal_merge"),
pytest.param([StringLiteral({str(i)}) for i in range(100)],
DUnion(str),
id="str_literal_too_much"),
]
@pytest.mark.parametrize("value,expected", test_dunion)
def test_dunion_creation(value, expected):
result = DUnion(*value)
assert result == expected
import pytest
from json_to_models.dynamic_typing import (BooleanString, DDict, DList, DOptional, DTuple, DUnion, FloatString,
IntString, Null, Unknown)
from json_to_models.generator import MetadataGenerator
# MetaData | Optimized MetaData
test_data = [
pytest.param(DUnion(int), int, id="single_DUnion"),
pytest.param(
{'a': DUnion({'b': int}, {'b': float})},
{'a': {'b': float}},
id="merge_nested_dicts"
),
pytest.param(
{'1': DUnion(
{'a': DUnion({'b': int}, {'b': float})},
{'a': DUnion({'b': float}, {'b': int})},
{'a': Null},
)},
{'1': {'a': DOptional({'b': float})}},
id="merge_nested_dicts"
),
pytest.param(
DUnion(FloatString, IntString),
FloatString,
id="str_types_merge"
),
pytest.param(
DUnion(FloatString, BooleanString),
str,