def test_simple(self): @dataclass class Foo: some_field: str assert get_type_tree(Foo, locals()) == Object( "Foo", Foo, {"some_field": Primitive(str)})
def match(cls, pytype: type, localns=None): if is_dataclass(pytype): field_hints = get_dataclass_type_hints(pytype, localns=localns) fields = { field_name: get_type_tree(subtype, localns) for field_name, subtype in field_hints.items() } return Object(pytype.__name__, constructor=pytype, fields=fields)
def match(cls, pytype: type, localns=None) -> typing.Optional[AbstractNode]: if (hasattr(pytype, "__origin__" ) # isinstance(Union[...], GenericAlias) returns False and pytype.__origin__ == typing.Union and len(pytype.__args__) == 2 and type(None) in pytype.__args__): other = [arg for arg in pytype.__args__ if arg is not type(None)][0] return Nullable(get_type_tree(other))
def test_nested(self): @dataclass class Bar: other_field: str @dataclass class Foo: some_field: Bar list_field: list[Bar] expected_bar_node = Object("Bar", Bar, {"other_field": Primitive(str)}) assert get_type_tree(Foo, locals()) == Object( "Foo", Foo, { "some_field": expected_bar_node, "list_field": List(expected_bar_node) })
def test_api_gen(): foo_type_tree = get_type_tree(Foo) ctx = CodeSnippetContext() func_code = build_ts_func("getFoo", foo_type_tree, None, "/api/foo/<my_id>", ["my_id"], "GET", ctx) expected_func_code = """ export const getFoo = async (myId: string): Promise<Foo> => { const response = await fetch(`/api/foo/${myId}`, { method: 'GET' }); if (!response.ok) { throw new ApiError("HTTP status code: " + response.status, response); } return await response.json(); }""" assert func_code == expected_func_code assert ctx.natural_order() == ["ApiError", "Foo"]
def match(cls, pytype: type, localns=None): if isinstance(pytype, GenericAlias) and pytype.__origin__ == list: subtype = pytype.__args__[0] return List(element_node=get_type_tree(subtype, localns=localns))
def match(cls, pytype: type, localns=None) -> Optional[AbstractNode]: if isinstance(pytype, GenericAlias) and pytype.__origin__ == tuple: return Tuple([get_type_tree(f) for f in pytype.__args__])
def test_date(): assert get_type_tree(datetime.date) == Date() source = datetime.date(2020, 10, 1) assert Date().create_dto(source) == "2020-10-01" assert Date().parse_dto("2020-10-01") == source
def test_datetime(): assert get_type_tree(datetime.datetime) == DateTime() source = datetime.datetime(2020, 10, 1, 3, 2, 1) assert DateTime().create_dto(source) == "2020-10-01T03:02:01Z" assert DateTime().parse_dto("2020-10-01T03:02:01Z") == source
def test_primitives(): assert get_type_tree(int) == Primitive(int) assert get_type_tree(float) == Primitive(float) assert get_type_tree(str) == Primitive(str) assert get_type_tree(bool) == Primitive(bool)
def test_tree_parsing(self): assert get_type_tree(dict[str, int]) == Dict(Primitive(int)) t = get_type_tree(dict[int, str]) assert t == UnsupportedTypeNode(dict[int, str]) with pytest.raises(UnsupportedTypeError): t.ts_repr(CodeSnippetContext())
def test_tree_parsing(self): assert get_type_tree(list[str]) == List(Primitive(str)) assert get_type_tree(list[list[bool]]) == List(List(Primitive(bool)))
def match(cls, pytype: type, localns=None) -> Optional[AbstractNode]: if isinstance(pytype, GenericAlias) and pytype.__origin__ == dict: if pytype.__args__[0] != str: # js "objects" only properly support string keys return UnsupportedTypeNode(pytype) return Dict(get_type_tree(pytype.__args__[1], localns=localns))