Merge pull request #3285 from silasary/forward_typed_dict

Author: Zac-HD

AUTHORS.rst

@@ -79,6 +79,7 @@ their individual contributions.
 * `jwg4 <https://www.github.com/jwg4>`_
 * `Kai Chen <https://www.github.com/kx-chen>`_ ([email protected])
 * `Karthikeyan Singaravelan <https://www.github.com/tirkarthi>`_ ([email protected])
+* `Katelyn Gigante <https://github.com/silasary>`_
 * `Katrina Durance <https://github.com/kdurance>`_
 * `kbara <https://www.github.com/kbara>`_
 * `Kristian Glass <https://www.github.com/doismellburning>`_

hypothesis-python/RELEASE.rst

@@ -0,0 +1,5 @@
+RELEASE_TYPE: patch
+
+This patch fixes :func:`~hypothesis.strategies.from_type` on a :class:`~python:typing.TypedDict`
+with complex annotations, defined in a file using ``from __future__ import annotations``.
+Thanks to Katelyn Gigante for identifying and fixing this bug!

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

@@ -1076,7 +1076,13 @@ def as_strategy(strat_or_callable, thing, final=True):
         # way to tell and we just have to assume that everything is required.
         # See https://github.com/python/cpython/pull/17214 for details.
         optional = getattr(thing, "__optional_keys__", ())
-        anns = {k: from_type(v) for k, v in thing.__annotations__.items()}
+        anns = {k: from_type(v) for k, v in get_type_hints(thing).items()}
+        if (
+            (not anns)
+            and thing.__annotations__
+            and ".<locals>." in getattr(thing, "__qualname__", "")
+        ):
+            raise InvalidArgument("Failed to retrieve type annotations for local type")
         return fixed_dictionaries(  # type: ignore
             mapping={k: v for k, v in anns.items() if k not in optional},
             optional={k: v for k, v in anns.items() if k in optional},

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

@@ -10,7 +10,7 @@
 
 import sys
 import warnings
-from collections import defaultdict
+from collections import abc, defaultdict
 from random import shuffle
 from typing import (
     Any,
@@ -811,17 +811,22 @@ def pack(self, x):
         raise NotImplementedError(f"{self.__class__.__name__}.pack()")
 
     def do_draw(self, data: ConjectureData) -> Ex:
-        for _ in range(3):
-            i = data.index
-            try:
-                data.start_example(MAPPED_SEARCH_STRATEGY_DO_DRAW_LABEL)
-                result = self.pack(data.draw(self.mapped_strategy))
-                data.stop_example()
-                return result
-            except UnsatisfiedAssumption:
-                data.stop_example(discard=True)
-                if data.index == i:
-                    raise
+        with warnings.catch_warnings():
+            if isinstance(self.pack, type) and issubclass(
+                self.pack, (abc.Mapping, abc.Set)
+            ):
+                warnings.simplefilter("ignore", BytesWarning)
+            for _ in range(3):
+                i = data.index
+                try:
+                    data.start_example(MAPPED_SEARCH_STRATEGY_DO_DRAW_LABEL)
+                    result = self.pack(data.draw(self.mapped_strategy))
+                    data.stop_example()
+                    return result
+                except UnsatisfiedAssumption:
+                    data.stop_example(discard=True)
+                    if data.index == i:
+                        raise
         raise UnsatisfiedAssumption()
 
     @property

hypothesis-python/tests/cover/test_lookup.py

@@ -713,6 +713,11 @@ def test_generic_collections_only_use_hashable_elements(typ, data):
     data.draw(from_type(typ))
 
 
+@given(st.sets(st.integers() | st.binary(), min_size=2))
+def test_no_byteswarning(_):
+    pass
+
+
 def test_hashable_type_unhashable_value():
     # Decimal("snan") is not hashable; we should be able to generate it.
     # See https://github.com/HypothesisWorks/hypothesis/issues/2320

hypothesis-python/tests/nocover/test_type_lookup_future_annotations.py

@@ -0,0 +1,48 @@
+# This file is part of Hypothesis, which may be found at
+# https://github.com/HypothesisWorks/hypothesis/
+#
+# Copyright the Hypothesis Authors.
+# Individual contributors are listed in AUTHORS.rst and the git log.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public License,
+# 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 __future__ import annotations
+
+from typing import TypedDict, Union
+
+import pytest
+
+from hypothesis import given, strategies as st
+from hypothesis.errors import InvalidArgument
+
+alias = Union[int, str]
+
+
+class A(TypedDict):
+    a: int
+
+
+class B(TypedDict):
+    a: A
+    b: alias
+
+
+@given(st.from_type(B))
+def test_complex_forward_ref_in_typed_dict(d):
+    assert isinstance(d["a"], dict)
+    assert isinstance(d["a"]["a"], int)
+    assert isinstance(d["b"], (int, str))
+
+
+def test_complex_forward_ref_in_typed_dict_local():
+    local_alias = Union[int, str]
+
+    class C(TypedDict):
+        a: A
+        b: local_alias
+
+    c_strategy = st.from_type(C)
+    with pytest.raises(InvalidArgument):
+        c_strategy.example()