Merge pull request #4629 from Zac-HD/claude/fix-hypothesis-4628-9Gp2O

Fix `from_type()` to handle parameterized type aliases

Author: Zac-HD

hypothesis-python/RELEASE.rst

@@ -0,0 +1,7 @@
+RELEASE_TYPE: patch
+
+This patch fixes :func:`~hypothesis.strategies.from_type` to properly handle
+parameterized type aliases created with Python 3.12+'s :pep:`695` ``type``
+statement. For example, ``st.from_type(A[int])`` where ``type A[T] = list[T]``
+now correctly resolves to ``lists(integers())`` instead of raising a
+``TypeError`` (:issue:`4628`).

hypothesis-python/src/hypothesis/strategies/_internal/core.py

@@ -1348,6 +1348,16 @@ def from_type_guarded(thing):
             if strategy is not NotImplemented:
                 return strategy
         return _from_type(thing.__value__)  # type: ignore
+    if types.is_a_type_alias_type(origin := get_origin(thing)):  # pragma: no cover
+        # Handle parametrized type aliases like `type A[T] = list[T]; thing = A[int]`.
+        # In this case, `thing` is a GenericAlias whose origin is a TypeAliasType.
+        #
+        # covered by 3.12+ tests.
+        if origin in types._global_type_lookup:
+            strategy = as_strategy(types._global_type_lookup[origin], thing)
+            if strategy is not NotImplemented:
+                return strategy
+        return _from_type(types.evaluate_type_alias_type(thing))
     if types.is_a_union(thing):
         args = sorted(thing.__args__, key=types.type_sorting_key)  # type: ignore
         return one_of([_from_type(t) for t in args])
@@ -1397,9 +1407,9 @@ def from_type_guarded(thing):
                 return strategy
         elif (
             isinstance(thing, GenericAlias)
-            and (to := get_origin(thing)) in types._global_type_lookup
+            and (origin := get_origin(thing)) in types._global_type_lookup
         ):
-            strategy = as_strategy(types._global_type_lookup[to], thing)
+            strategy = as_strategy(types._global_type_lookup[origin], thing)
             if strategy is not NotImplemented:
                 return strategy
     except TypeError:  # pragma: no cover

hypothesis-python/src/hypothesis/strategies/_internal/types.py

@@ -35,7 +35,12 @@
 from typing import TYPE_CHECKING, Any, NewType, get_args, get_origin
 
 from hypothesis import strategies as st
-from hypothesis.errors import HypothesisWarning, InvalidArgument, ResolutionFailed
+from hypothesis.errors import (
+    HypothesisException,
+    HypothesisWarning,
+    InvalidArgument,
+    ResolutionFailed,
+)
 from hypothesis.internal.compat import PYPY, BaseExceptionGroup, ExceptionGroup
 from hypothesis.internal.conjecture.utils import many as conjecture_utils_many
 from hypothesis.internal.filtering import max_len, min_len
@@ -252,6 +257,67 @@ def try_issubclass(thing, superclass):
         return False
 
 
+def _evaluate_type_alias_type(thing, *, typevars):  # pragma: no cover # 3.12+
+    if isinstance(thing, typing.TypeVar):
+        if thing not in typevars:
+            raise ValueError(
+                f"Cannot look up value for unbound type var {thing}. "
+                f"Bound typevars: {typevars}"
+            )
+        return typevars[thing]
+
+    origin = get_origin(thing)
+    if origin is None:
+        # not a parametrized type, so nothing to substitute.
+        return thing
+
+    args = get_args(thing)
+    # we had an origin, so we must have an args
+    # note: I'm only mostly confident this is true and there may be a subtle
+    # violator.
+    assert args
+
+    concrete_args = tuple(
+        _evaluate_type_alias_type(arg, typevars=typevars) for arg in args
+    )
+    if isinstance(origin, typing.TypeAliasType):
+        for param in origin.__type_params__:
+            # there's no principled reason not to support these, they're just
+            # annoying to implement.
+            if isinstance(param, typing.TypeVarTuple):
+                raise HypothesisException(
+                    f"Hypothesis does not yet support resolution for TypeVarTuple "
+                    f"{param} (in origin: {origin!r}). Please open an issue if "
+                    "you would like to see support for this."
+                )
+            if isinstance(param, typing.ParamSpec):
+                raise HypothesisException(
+                    f"Hypothesis does not yet support resolution for ParamSpec "
+                    f"{param} (in origin: {origin!r}). Please open an issue if you "
+                    "would like to see support for this."
+                )
+        # this zip is non-strict to allow for e.g.
+        # `type A[T1, T2] = list[T1]; st.from_type(A[int]).example()`,
+        # which leaves T2 free but is still acceptable as it never references
+        # it.
+        #
+        # We disallow referencing a free / unbound type var by erroring
+        # elsewhere in this function.
+        typevars |= dict(zip(origin.__type_params__, concrete_args, strict=False))
+        return _evaluate_type_alias_type(origin.__value__, typevars=typevars)
+
+    return origin[concrete_args]
+
+
+def evaluate_type_alias_type(thing):  # pragma: no cover # covered on 3.12+
+    # this function takes a GenericAlias whose origin is a TypeAliasType,
+    # which corresponds to `type A[T] = list[T]; thing = A[int]`, and returns
+    # the fully-instantiated underlying type.
+    assert isinstance(thing, GenericAlias)
+    assert is_a_type_alias_type(get_origin(thing))
+    return _evaluate_type_alias_type(thing, typevars={})
+
+
 def is_a_type_alias_type(thing):  # pragma: no cover # covered by 3.12+ tests
     # TypeAliasType is new in python 3.12, through the type statement. If we're
     # before python 3.12 then this can't possibly by a TypeAliasType.

hypothesis-python/tests/cover/test_typealias_py312.py

@@ -8,9 +8,14 @@
 # v. 2.0. If a copy of the MPL was not distributed with this file, You can
 # obtain one at https://mozilla.org/MPL/2.0/.
 
+from collections.abc import Callable
+from typing import get_args, get_origin
+
 import pytest
 
 from hypothesis import strategies as st
+from hypothesis.errors import HypothesisException
+from hypothesis.strategies._internal.types import evaluate_type_alias_type
 
 from tests.common.debug import assert_simple_property, find_any
 from tests.common.utils import temp_registered
@@ -39,6 +44,13 @@ def test_resolves_nested():
     assert_simple_property(st.from_type(Point3), lambda x: isinstance(x, int))
 
 
+def test_resolves_parametrized():
+    type MyList = list[int]
+    assert_simple_property(
+        st.from_type(MyList), lambda l: all(isinstance(x, int) for x in l)
+    )
+
+
 def test_mutually_recursive_fails():
     # example from
     # https://docs.python.org/3/library/typing.html#typing.TypeAliasType.__value__
@@ -51,6 +63,15 @@ def test_mutually_recursive_fails():
         find_any(st.from_type(A))
 
 
+def test_mutually_recursive_fails_parametrized():
+    # same with parametrized types
+    type A[T] = B[T]
+    type B[T] = A[T]
+
+    with pytest.raises(RecursionError):
+        find_any(st.from_type(A[int]))
+
+
 def test_can_register_typealias():
     type A = int
     st.register_type_strategy(A, st.just("a"))
@@ -65,3 +86,94 @@ def test_prefers_manually_registered_typealias():
 
     with temp_registered(A, st.booleans()):
         assert_simple_property(st.from_type(A), lambda x: isinstance(x, bool))
+
+
+def test_resolves_parameterized_typealias():
+    type A[T] = list[T]
+
+    assert_simple_property(st.from_type(A[int]), lambda x: isinstance(x, list))
+    find_any(st.from_type(A[int]), lambda x: len(x) > 0)
+    assert_simple_property(
+        st.from_type(A[int]), lambda x: all(isinstance(i, int) for i in x)
+    )
+
+
+def test_resolves_nested_parameterized_typealias():
+    type Inner[T] = list[T]
+    type Outer[T] = Inner[T]
+
+    assert_simple_property(st.from_type(Outer[str]), lambda x: isinstance(x, list))
+    assert_simple_property(
+        st.from_type(Outer[str]), lambda x: all(isinstance(i, str) for i in x)
+    )
+
+
+def test_resolves_parameterized_typealias_with_literal_types():
+    # Type param used in non-first position with literal types
+    type MyDict[T] = dict[str, T]
+
+    assert_simple_property(st.from_type(MyDict[int]), lambda x: isinstance(x, dict))
+    assert_simple_property(
+        st.from_type(MyDict[int]),
+        lambda x: all(isinstance(k, str) and isinstance(v, int) for k, v in x.items()),
+    )
+
+
+def test_can_register_parameterized_typealias_with_unused_params():
+    # Users can explicitly register strategies for such types using a resolver function
+    type MyList[T1, T2] = list[T1]
+
+    # Register a function that resolves the type alias
+    def resolve_mylist(thing):
+        if get_origin(thing) is MyList:
+            args = get_args(thing)
+            # Use the first type argument, ignore the second
+            return st.lists(st.from_type(args[0]))
+        return NotImplemented
+
+    st.register_type_strategy(MyList, resolve_mylist)
+
+    assert_simple_property(
+        st.from_type(MyList[int, float]), lambda x: isinstance(x, list)
+    )
+    assert_simple_property(
+        st.from_type(MyList[int, float]), lambda x: all(isinstance(i, int) for i in x)
+    )
+
+
+def test_typealias_evaluation():
+    type A[T1, T2] = list[T1]
+    assert evaluate_type_alias_type(A[int, float]) == list[int]
+
+    type A[T1, T2] = list[T2]
+    assert evaluate_type_alias_type(A[float, int]) == list[int]
+
+    type A[K, V] = dict[V, K]
+    assert evaluate_type_alias_type(A[str, int]) == dict[int, str]
+
+    type A[T] = list[list[T]]
+    assert evaluate_type_alias_type(A[int]) == list[list[int]]
+
+    type Inner[T] = list[T]
+    type Outer[T] = Inner[T]
+    assert evaluate_type_alias_type(Outer[int]) == list[int]
+
+    type Bare[T] = list
+    assert evaluate_type_alias_type(Bare[int]) == list
+
+    type A[T1, T2] = list[T1]
+    assert evaluate_type_alias_type(A[int]) == list[int]
+
+    # tries to reference free variable
+    type A[T1, T2] = list[T2]
+    with pytest.raises(ValueError):
+        evaluate_type_alias_type(A[int])
+
+    # (currently) unsupported type forms
+    type A[*Ts] = tuple[*Ts]
+    with pytest.raises(HypothesisException, match="Hypothesis does not yet support"):
+        assert evaluate_type_alias_type(A[int, str, float]) == tuple[int, str, float]
+
+    type A[**P] = Callable[P, int]
+    with pytest.raises(HypothesisException, match="Hypothesis does not yet support"):
+        assert evaluate_type_alias_type(A[[str, float]]) == Callable[[str, float], int]

hypothesis-python/tests/crosshair/test_crosshair.py

@@ -46,6 +46,9 @@ def f(n):
 @pytest.mark.parametrize("verbosity", list(Verbosity))
 def test_crosshair_works_for_all_verbosities_data(verbosity):
     # data draws have their own print path
+    if verbosity == Verbosity.quiet:
+        pytest.skip("Flaky test, pending fix")
+
     @given(st.data())
     @settings(
         backend="crosshair",