prevent tuple subclasses from being interpreted as generic

AUTHORS.rst

@@ -107,6 +107,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,3 @@
+RELEASE_TYPE: patch
+
+This patch improves `st.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])`.

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

@@ -1053,3 +1053,18 @@ def f(x: int):
     msg = "@no_type_check decorator prevented Hypothesis from inferring a strategy"
     with pytest.raises(TypeError, match=msg):
         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)):
+
+        @given(st.from_type(typing.Sequence[int]))
+        def f(val):
+            assert not isinstance(val, tuple)
+
+        f()