Merge pull request #3768 from tybug/namedtuple-generic

AUTHORS.rst

@@ -108,6 +108,7 @@ their individual contributions.
 * `Lampros Mountrakis <https://www.github.com/lmount>`_
 * `Lea Provenzano <https://github.com/leaprovenzano>`_
 * `Lee Begg <https://www.github.com/llnz2>`_
+* `Liam DeVoe <https://github.com/tybug>`_
 * `Libor Martínek <https://github.com/bibajz>`_
 * `Lisa Goeller <https://www.github.com/lgoeller>`_
 * `Louis Taylor <https://github.com/kragniz>`_

hypothesis-python/RELEASE.rst

@@ -0,0 +1,5 @@
+RELEASE_TYPE: patch
+
+This patch improves :func:`~hypothesis.strategies.register_type_strategy` when used with ``tuple`` subclasses, 
+by preventing them from being interpreted as generic and provided to strategies like ``st.from_type(Sequence[int])``
+(:issue:`3767`).

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

@@ -391,10 +391,16 @@ def from_typing_type(thing):
         for k, v in _global_type_lookup.items()
         if is_generic_type(k) and try_issubclass(k, thing)
     }
-    # Drop some unusual cases for simplicity
-    for weird in (tuple, getattr(os, "_Environ", None)):
-        if len(mapping) > 1:
-            mapping.pop(weird, None)
+    # Drop some unusual cases for simplicity, including tuples or its
+    # subclasses (e.g. namedtuple)
+    if len(mapping) > 1:
+        _Environ = getattr(os, "_Environ", None)
+        mapping.pop(_Environ, None)
+    tuple_types = [t for t in mapping if isinstance(t, type) and issubclass(t, tuple)]
+    if len(mapping) > len(tuple_types):
+        for tuple_type in tuple_types:
+            mapping.pop(tuple_type)
+
     # After we drop Python 3.8 and can rely on having generic builtin types, we'll
     # be able to simplify this logic by dropping the typing-module handling.
     if {dict, set, typing.Dict, typing.Set}.intersection(mapping):
@@ -407,6 +413,7 @@ def from_typing_type(thing):
         # the ghostwriter than it's worth, via undefined names in the repr.
         mapping.pop(collections.deque, None)
         mapping.pop(typing.Deque, None)
+
     if len(mapping) > 1:
         # issubclass treats bytestring as a kind of sequence, which it is,
         # but treating it as such breaks everything else when it is presumed

hypothesis-python/tests/cover/test_lookup.py

@@ -36,7 +36,12 @@
 from hypothesis.strategies import from_type
 from hypothesis.strategies._internal import types
 
-from tests.common.debug import assert_all_examples, find_any, minimal
+from tests.common.debug import (
+    assert_all_examples,
+    assert_no_examples,
+    find_any,
+    minimal,
+)
 from tests.common.utils import fails_with, temp_registered
 
 sentinel = object()
@@ -1146,6 +1151,17 @@ def f(x: int):
         st.builds(f).example()
 
 
+class TupleSubtype(tuple):
+    pass
+
+
+def test_tuple_subclasses_not_generic_sequences():
+    # see https://github.com/HypothesisWorks/hypothesis/issues/3767.
+    with temp_registered(TupleSubtype, st.builds(TupleSubtype)):
+        s = st.from_type(typing.Sequence[int])
+        assert_no_examples(s, lambda x: isinstance(x, tuple))
+
+
 def test_custom_strategy_function_resolves_types_conditionally():
     sentinel = object()
 

hypothesis-python/tests/cover/test_lookup_py39.py

@@ -125,3 +125,27 @@ def test_can_register_builtin_list():
             st.from_type(list[int]),
             lambda ls: len(ls) <= 2 and {type(x) for x in ls}.issubset({int}),
         )
+
+
+T = typing.TypeVar("T")
+
+
+@typing.runtime_checkable
+class Fooable(typing.Protocol[T]):
+    def foo(self):
+        ...
+
+
+class FooableConcrete(tuple):
+    def foo(self):
+        pass
+
+
+def test_only_tuple_subclasses_in_typing_type():
+    # A generic typing type (such as Fooable) whose only concrete
+    # instantiations are tuples should still generate tuples. This is in
+    # contrast to test_tuple_subclasses_not_generic_sequences, which discards
+    # tuples if there are any alternatives.
+    with temp_registered(FooableConcrete, st.builds(FooableConcrete)):
+        s = st.from_type(Fooable[int])
+        assert_all_examples(s, lambda x: type(x) is FooableConcrete)