diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 4107f3ec..cbfc0da6 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -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 diff --git a/atom/typing_utils.py b/atom/typing_utils.py index b5da29d3..42f4705e 100644 --- a/atom/typing_utils.py +++ b/atom/typing_utils.py @@ -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: diff --git a/tests/test_atom_from_annotations.py b/tests/test_atom_from_annotations.py index eac429f9..fd69d3bb 100644 --- a/tests/test_atom_from_annotations.py +++ b/tests/test_atom_from_annotations.py @@ -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: