Make SearchStrategy generic in the type of examples

Author: Zac-HD

.flake8

@@ -7,4 +7,4 @@ exclude =
     test_imports.py,
     hypothesis-python/tests/py2/*,
     test_lambda_formatting.py
-ignore = D1,D205,D209,D213,D400,D401,D999
+ignore = F811,D1,D205,D209,D213,D400,D401,D999

hypothesis-python/src/hypothesis/internal/renaming.py

@@ -22,8 +22,13 @@
 from hypothesis._settings import note_deprecation
 from hypothesis.internal.reflection import proxies
 
+if False:
+    from typing import Callable  # noqa
+    from hypothesis.searchstrategy.strategies import T  # noqa
+
 
 def renamed_arguments(**rename_mapping):
+    # type: (**str) -> Callable[[T], T]
     """Helper function for deprecating arguments that have been renamed to a
     new form.
 

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

@@ -22,7 +22,7 @@
 import hypothesis.internal.conjecture.utils as cu
 from hypothesis.errors import NoExamples, NoSuchExample, Unsatisfiable, \
     UnsatisfiedAssumption
-from hypothesis.control import assume, reject, _current_build_context
+from hypothesis.control import assume, _current_build_context
 from hypothesis._settings import note_deprecation
 from hypothesis.internal.compat import hrange, bit_length
 from hypothesis.utils.conventions import UniqueIdentifier
@@ -31,6 +31,18 @@
 from hypothesis.internal.conjecture.utils import LABEL_MASK, \
     combine_labels, calc_label_from_cls, calc_label_from_name
 
+try:
+    from random import Random  # noqa
+    from typing import List, Callable, TypeVar, Generic, Optional  # noqa
+    Ex = TypeVar('Ex', covariant=True)
+    T = TypeVar('T')
+
+    from hypothesis.internal.conjecture.data import ConjectureData  # noqa
+
+except ImportError:  # pragma: no cover
+    Ex = 'key'  # type: ignore
+    Generic = {Ex: object}  # type: ignore
+
 calculating = UniqueIdentifier('calculating')
 
 MAPPED_SEARCH_STRATEGY_DO_DRAW_LABEL = calc_label_from_name(
@@ -45,7 +57,7 @@ def one_of_strategies(xs):
     return OneOfStrategy(xs)
 
 
-class SearchStrategy(object):
+class SearchStrategy(Generic[Ex]):
     """A SearchStrategy is an object that knows how to explore data of a given
     type.
 
@@ -228,6 +240,7 @@ def calc_has_reusable_values(self, recur):
         return False
 
     def example(self, random=None):
+        # type: (Random) -> Ex
         """Provide an example of the sort of value that this strategy
         generates. This is biased to be slightly simpler than is typical for
         values from this strategy, for clarity purposes.
@@ -270,7 +283,7 @@ def example(self, random=None):
         # Conjecture will always try the zero example first. This would result
         # in us producing the same example each time, which is boring, so we
         # deliberately skip the first example it feeds us.
-        first = []
+        first = []  # type: list
 
         def condition(x):
             if first:
@@ -299,6 +312,7 @@ def condition(x):
             )
 
     def map(self, pack):
+        # type: (Callable[[Ex], T]) -> SearchStrategy[T]
         """Returns a new strategy that generates values by generating a value
         from this strategy and then calling pack() on the result, giving that.
 
@@ -309,6 +323,7 @@ def map(self, pack):
         )
 
     def flatmap(self, expand):
+        # type: (Callable[[Ex], SearchStrategy[T]]) -> SearchStrategy[T]
         """Returns a new strategy that generates values by generating a value
         from this strategy, say x, then generating a value from
         strategy(expand(x))
@@ -321,6 +336,7 @@ def flatmap(self, expand):
         )
 
     def filter(self, condition):
+        # type: (Callable[[Ex], bool]) -> SearchStrategy[Ex]
         """Returns a new strategy that generates values from this strategy
         which satisfy the provided condition. Note that if the condition is too
         hard to satisfy this might result in your tests failing with
@@ -335,6 +351,7 @@ def filter(self, condition):
 
     @property
     def branches(self):
+        # type: () -> List[SearchStrategy[Ex]]
         return [self]
 
     def __or__(self, other):
@@ -348,6 +365,7 @@ def __or__(self, other):
         return one_of_strategies((self, other))
 
     def validate(self):
+        # type: () -> None
         """Throw an exception if the strategy is not valid.
 
         This can happen due to lazy construction
@@ -392,6 +410,7 @@ def do_validate(self):
         pass
 
     def do_draw(self, data):
+        # type: (ConjectureData) -> Ex
         raise NotImplementedError('%s.do_draw' % (type(self).__name__,))
 
     def __init__(self):
@@ -469,6 +488,7 @@ def calc_label(self):
         ])
 
     def do_draw(self, data):
+        # type: (ConjectureData) -> Ex
         n = len(self.element_strategies)
         assert n > 0
         if n == 1:
@@ -538,6 +558,7 @@ def pack(self, x):  # type: ignore
             '%s.pack()' % (self.__class__.__name__))
 
     def do_draw(self, data):
+        # type: (ConjectureData) -> Ex
         for _ in range(3):
             i = data.index
             try:
@@ -549,10 +570,11 @@ def do_draw(self, data):
                 data.stop_example(discard=True)
                 if data.index == i:
                     raise
-        reject()
+        raise UnsatisfiedAssumption()
 
     @property
     def branches(self):
+        # type: () -> List[SearchStrategy[Ex]]
         return [
             MappedSearchStrategy(pack=self.pack, strategy=strategy)
             for strategy in self.mapped_strategy.branches
@@ -584,6 +606,7 @@ def do_validate(self):
         self.filtered_strategy.validate()
 
     def do_draw(self, data):
+        # type: (ConjectureData) -> Ex
         for i in hrange(3):
             start_index = data.index
             value = data.draw(self.filtered_strategy)
@@ -601,9 +624,11 @@ def do_draw(self, data):
             self,
         ))
         data.mark_invalid()
+        raise AssertionError('Unreachable, for Mypy')  # pragma: no cover
 
     @property
     def branches(self):
+        # type: () -> List[SearchStrategy[Ex]]
         return [
             FilteredStrategy(strategy=strategy, condition=self.condition)
             for strategy in self.filtered_strategy.branches