Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion .github/workflows/release.yml
Original file line number Diff line number Diff line change
Expand Up @@ -114,7 +114,7 @@ jobs:
path: dist
merge-multiple: true
- name: Sign the dists with Sigstore
uses: sigstore/gh-action-sigstore-python@v3.0.1
uses: sigstore/gh-action-sigstore-python@v3.4.0
with:
inputs: >-
./dist/*.tar.gz
Expand Down
60 changes: 40 additions & 20 deletions atom/typing_utils.py
Original file line number Diff line number Diff line change
Expand Up @@ -98,39 +98,59 @@ class ChangeDict(_ChangeDict, total=False):


def _resolve_type_alias(kind: Any, seen: set[int] | None = None) -> Any:
"""Resolve type aliases to their underlying annotation."""
if not _TYPE_ALIAS_TYPES or not isinstance(kind, _TYPE_ALIAS_TYPES):
return kind
"""Resolve a type alias down to its underlying runtime value."""
seen = set() if seen is None else seen
current = kind

if seen is None:
seen = set()
kind_id = id(kind)
if kind_id in seen:
raise TypeError(f"Cyclic type alias {kind!r} is not supported.")
seen.add(kind_id)
return _resolve_type_alias(kind.__value__, seen)
while True:
if id(current) in seen:
raise RuntimeError(
f"Failed to resolve type alias for {kind}, which is recursive."
) # pragma: no cover
seen.add(id(current))

if _TYPE_ALIAS_TYPES and isinstance(current, _TYPE_ALIAS_TYPES):
current = current.__value__
continue

return current


def _resolve_generic_origin(kind: Any, seen: set[int] | None = None) -> Any:
"""Resolve alias-backed generic origins to their concrete runtime type."""
seen = set() if seen is None else seen
current = _resolve_type_alias(kind, seen)

while True:
origin = get_origin(current)
if origin is None:
return current if isinstance(current, type) else None
if isinstance(origin, type):
return origin
current = _resolve_type_alias(origin, seen)


def _extract_types(kind: TypeLike) -> Tuple[type, ...]:
"""Extract a tuple of types from a type-like object"""
kind = _resolve_type_alias(kind)
if isinstance(kind, _INVALID_TYPES):
raise TypeError(
f"Str-based annotations ({kind!r}) are not supported in atom Members."
)

kind = _resolve_type_alias(kind)

ret: List[Any]
if isinstance(kind, GENERICS):
args = get_args(kind)
origin = get_origin(kind)
if origin is Union:
ret = list(chain.from_iterable(extract_types(a) for a in args))
else:
ret = [origin]
elif UNION and isinstance(kind, UNION):
origin = get_origin(kind)
if origin is Union or (UNION and isinstance(kind, UNION)):
ret = list(chain.from_iterable(extract_types(a) for a in get_args(kind)))
else:
ret = [kind]
resolved_origin = _resolve_generic_origin(kind)
if resolved_origin is not None:
ret = [resolved_origin]
elif isinstance(kind, GENERICS):
ret = [kind]
else:
ret = [kind]

extracted: List[type] = []
for t in ret:
Expand Down
133 changes: 133 additions & 0 deletions tests/test_atom_from_annotations.py
Original file line number Diff line number Diff line change
Expand Up @@ -125,6 +125,139 @@ class A(Atom, use_annotations=True, type_containers=1):
assert isinstance(A.a.item, Int)


def test_bare_type_alias_in_annotation():
try:
from typing_extensions import TypeAliasType
except ImportError:
pytest.skip("typing_extensions.TypeAliasType is unavailable")

Alias = TypeAliasType("Alias", int)

class A(Atom, use_annotations=True):
a: Alias

assert isinstance(A.a, Int)


def test_type_alias_to_union_in_annotation():
try:
from typing_extensions import TypeAliasType
except ImportError:
pytest.skip("typing_extensions.TypeAliasType is unavailable")

Alias = TypeAliasType("Alias", int | str)

class A(Atom, use_annotations=True):
a: Alias

assert isinstance(A.a, Instance)
assert A.a.validate_mode[1] == (int, str)


def test_alias_of_alias_in_annotation():
try:
from typing_extensions import TypeAliasType
except ImportError:
pytest.skip("typing_extensions.TypeAliasType is unavailable")

Inner = TypeAliasType("Inner", int | str)
Outer = TypeAliasType("Outer", Inner)

class A(Atom, use_annotations=True):
a: Outer

assert isinstance(A.a, Instance)
assert A.a.validate_mode[1] == (int, str)


def test_deep_alias_chain_in_annotation():
try:
from typing_extensions import TypeAliasType
except ImportError:
pytest.skip("typing_extensions.TypeAliasType is unavailable")

Inner = TypeAliasType("Inner", int | str)
Middle = TypeAliasType("Middle", Inner)
Outer = TypeAliasType("Outer", list[Middle])

class A(Atom, use_annotations=True, type_containers=1):
a: Outer

assert isinstance(A.a, List)
assert isinstance(A.a.item, Instance)
assert A.a.item.validate_mode[1] == (int, str)


def test_nested_type_alias_in_annotation():
try:
from typing_extensions import TypeAliasType
except ImportError:
pytest.skip("typing_extensions.TypeAliasType is unavailable")

Inner = TypeAliasType("Inner", int | str)
Outer = TypeAliasType("Outer", list[Inner])

class A(Atom, use_annotations=True, type_containers=1):
a: Outer

assert isinstance(A.a, List)
assert isinstance(A.a.item, Instance)
assert A.a.item.validate_mode[1] == (int, str)


def test_generic_type_alias_in_annotation():
try:
from typing_extensions import TypeAliasType
except ImportError:
pytest.skip("typing_extensions.TypeAliasType is unavailable")

from typing import Generic

S = TypeVar("S")
T = TypeVar("T")

class ndarray(Generic[S, T]):
pass

NDArray = TypeAliasType("NDArray", ndarray[tuple[int, ...], T], type_params=(T,))

class A(Atom, use_annotations=True):
a: NDArray[int]

assert isinstance(A.a, Typed)
assert A.a.validate_mode[1] is ndarray

class B(Atom, use_annotations=True):
a: NDArray[int | str]

assert isinstance(B.a, Typed)
assert B.a.validate_mode[1] is ndarray


def test_generic_type_alias_inside_generic_in_annotation():
try:
from typing_extensions import TypeAliasType
except ImportError:
pytest.skip("typing_extensions.TypeAliasType is unavailable")

from typing import Generic

S = TypeVar("S")
T = TypeVar("T")

class ndarray(Generic[S, T]):
pass

NDArray = TypeAliasType("NDArray", ndarray[tuple[int, ...], T], type_params=(T,))

class A(Atom, use_annotations=True):
a: list[NDArray[int]]

assert isinstance(A.a, List)
assert isinstance(A.a.validate_mode[1], Typed)
assert A.a.validate_mode[1].validate_mode[1] is ndarray


def test_reject_bare_member_annotated_member():
with pytest.raises(ValueError) as e:

Expand Down
Loading