Merge pull request #3247 from HypothesisWorks/enable-ellipses

Author: Zac-HD

hypothesis-python/RELEASE.rst

@@ -0,0 +1,6 @@
+RELEASE_TYPE: minor
+
+This release changes the implementation of :const:`~hypothesis.infer` to be an alias 
+for :obj:`python:Ellipsis`. E.g. ``@given(a=infer)`` is now equivalent to ``@given(a=...)``. Furthermore, ``@given(...)`` can now be specified so that 
+:func:`@given <hypothesis.given>` will infer the strategies for *all* arguments of the
+decorated function based on its annotations.

hypothesis-python/docs/details.rst

@@ -561,7 +561,7 @@ limits.
 If there are required arguments with type annotations and
 no strategy was passed to :func:`~hypothesis.strategies.builds`,
 :func:`~hypothesis.strategies.from_type` is used to fill them in.
-You can also pass the special value :const:`hypothesis.infer` as a keyword
+You can also pass the value ``...`` (``Ellipsis``) as a keyword
 argument, to force this inference for arguments with a default value.
 
 .. code-block:: pycon
@@ -576,21 +576,38 @@ argument, to force this inference for arguments with a default value.
 
 :func:`@given <hypothesis.given>` does not perform any implicit inference
 for required arguments, as this would break compatibility with pytest fixtures.
-:const:`~hypothesis.infer` can be used as a keyword argument to explicitly
-fill in an argument from its type annotation.
+``...`` (:obj:`python:Ellipsis`), can be used as a keyword argument to explicitly fill
+in an argument from its type annotation.  You can also use the ``hypothesis.infer``
+alias if writing a literal ``...`` seems too weird.
 
 .. code:: python
 
-    @given(a=infer)
+    @given(a=...)  # or @given(a=infer)
     def test(a: int):
         pass
 
 
     # is equivalent to
-    @given(a=integers())
+    @given(a=from_type(int))
     def test(a):
         pass
 
+
+``@given(...)`` can also be specified to fill all arguments from their type annotations.
+
+.. code:: python
+
+    @given(...)
+    def test(a: int, b: str):
+        pass
+
+
+    # is equivalent to
+    @given(a=..., b=...)
+    def test(a, b):
+        pass
+
+
 ~~~~~~~~~~~
 Limitations
 ~~~~~~~~~~~

hypothesis-python/src/hypothesis/core.py

@@ -22,6 +22,7 @@
 import zlib
 from collections import defaultdict
 from io import StringIO
+from itertools import chain
 from random import Random
 from typing import (
     Any,
@@ -106,10 +107,17 @@
     MappedSearchStrategy,
     SearchStrategy,
 )
-from hypothesis.utils.conventions import InferType, infer
+from hypothesis.utils.conventions import infer
 from hypothesis.vendor.pretty import RepresentationPrinter
 from hypothesis.version import __version__
 
+if sys.version_info >= (3, 10):  # pragma: no cover
+    from types import EllipsisType as InferType
+
+else:
+    InferType = type(Ellipsis)
+
+
 TestFunc = TypeVar("TestFunc", bound=Callable)
 
 
@@ -275,8 +283,9 @@ def wrapped_test(*arguments, **kwargs):
 
     if infer in given_arguments:
         return invalid(
-            "infer was passed as a positional argument to @given, "
-            "but may only be passed as a keyword argument"
+            "... was passed as a positional argument to @given, "
+            "but may only be passed as a keyword argument or as "
+            "the sole argument of @given"
         )
 
     if given_arguments and given_kwargs:
@@ -983,6 +992,14 @@ def run_test_as_given(test):
 
         original_argspec = getfullargspec(test)
 
+        if given_arguments == (Ellipsis,) and not given_kwargs:
+            # user indicated that they want to infer all arguments
+            given_kwargs.update(
+                (name, Ellipsis)
+                for name in chain(original_argspec.args, original_argspec.kwonlyargs)
+            )
+            given_arguments = ()
+
         check_invalid = is_invalid_test(
             test, original_argspec, given_arguments, given_kwargs
         )
@@ -1016,7 +1033,7 @@ def run_test_as_given(test):
                 def wrapped_test(*arguments, **kwargs):
                     __tracebackhide__ = True
                     raise InvalidArgument(
-                        f"passed {name}=infer for {test.__name__}, but {name} has "
+                        f"passed {name}=... for {test.__name__}, but {name} has "
                         "no type annotation"
                     )
 

hypothesis-python/src/hypothesis/errors.py

@@ -79,7 +79,7 @@ class ResolutionFailed(InvalidArgument):
 
     Type inference is best-effort, so this only happens when an
     annotation exists but could not be resolved for a required argument
-    to the target of ``builds()``, or where the user passed ``infer``.
+    to the target of ``builds()``, or where the user passed ``...``.
     """
 
 

hypothesis-python/src/hypothesis/extra/django/_fields.py

@@ -290,7 +290,8 @@ def from_field(field: F) -> st.SearchStrategy[Union[F, None]]:
 
     This function is used by :func:`~hypothesis.extra.django.from_form` and
     :func:`~hypothesis.extra.django.from_model` for any fields that require
-    a value, or for which you passed :obj:`hypothesis.infer`.
+    a value, or for which you passed ``...`` (:obj:`python:Ellipsis`) to infer
+    a strategy from an annotation.
 
     It's pretty similar to the core :func:`~hypothesis.strategies.from_type`
     function, with a subtle but important difference: ``from_field`` takes a

hypothesis-python/src/hypothesis/extra/django/_impl.py

@@ -24,7 +24,13 @@
 from hypothesis.extra.django._fields import from_field
 from hypothesis.internal.reflection import define_function_signature_from_signature
 from hypothesis.strategies._internal.utils import defines_strategy
-from hypothesis.utils.conventions import InferType, infer
+from hypothesis.utils.conventions import infer
+
+if sys.version_info >= (3, 10):  # pragma: no cover
+    from types import EllipsisType as InferType
+
+else:
+    InferType = type(Ellipsis)
 
 
 class HypothesisTestCase:
@@ -84,7 +90,7 @@ def from_model(
         shop_strategy = from_model(Shop, company=from_model(Company))
 
     Like for :func:`~hypothesis.strategies.builds`, you can pass
-    :obj:`~hypothesis.infer` as a keyword argument to infer a strategy for
+    ``...`` (:obj:`python:Ellipsis`) as a keyword argument to infer a strategy for
     a field which has a default value instead of using the default.
     """
     if len(model) == 1:
@@ -171,7 +177,7 @@ def from_form(
         shop_strategy = from_form(Shop, form_kwargs={"company_id": 5})
 
     Like for :func:`~hypothesis.strategies.builds`, you can pass
-    :obj:`~hypothesis.infer` as a keyword argument to infer a strategy for
+    ``...`` (:obj:`python:Ellipsis`) as a keyword argument to infer a strategy for
     a field which has a default value instead of using the default.
     """
     # currently unsupported:

hypothesis-python/src/hypothesis/extra/ghostwriter.py

@@ -112,7 +112,14 @@
     SampledFromStrategy,
 )
 from hypothesis.strategies._internal.types import _global_type_lookup, is_generic_type
-from hypothesis.utils.conventions import InferType, infer
+from hypothesis.utils.conventions import infer
+
+if sys.version_info >= (3, 10):  # pragma: no cover
+    from types import EllipsisType as InferType
+
+else:
+    InferType = type(Ellipsis)
+
 
 IMPORT_SECTION = """
 # This test code was written by the `hypothesis.extra.ghostwriter` module

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

@@ -36,7 +36,7 @@ def from_attrs(target, args, kwargs, to_infer):
 def from_attrs_attribute(attrib, target):
     """Infer a strategy from the metadata on an attr.Attribute object."""
     # Try inferring from the default argument.  Note that this will only help if
-    # the user passed `infer` to builds() for this attribute, but in that case
+    # the user passed `...` to builds() for this attribute, but in that case
     # we use it as the minimal example.
     default = st.nothing()
     if isinstance(attrib.default, attr.Factory):

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

@@ -104,7 +104,14 @@
     TextStrategy,
 )
 from hypothesis.strategies._internal.utils import cacheable, defines_strategy
-from hypothesis.utils.conventions import InferType, infer, not_set
+from hypothesis.utils.conventions import infer, not_set
+
+if sys.version_info >= (3, 10):  # pragma: no cover
+    from types import EllipsisType as InferType
+
+else:
+    InferType = type(Ellipsis)
+
 
 try:
     from typing import Protocol
@@ -841,9 +848,9 @@ def builds(
 
     If the callable has type annotations, they will be used to infer a strategy
     for required arguments that were not passed to builds.  You can also tell
-    builds to infer a strategy for an optional argument by passing the special
-    value :const:`hypothesis.infer` as a keyword argument to
-    builds, instead of a strategy for that argument to the callable.
+    builds to infer a strategy for an optional argument by passing ``...``
+    (:obj:`python:Ellipsis`) as a keyword argument to builds, instead of a strategy for
+    that argument to the callable.
 
     If the callable is a class defined with :pypi:`attrs`, missing required
     arguments will be inferred from the attribute on a best-effort basis,
@@ -868,7 +875,7 @@ def builds(
     if infer in args:
         # Avoid an implementation nightmare juggling tuples and worse things
         raise InvalidArgument(
-            "infer was passed as a positional argument to "
+            "... was passed as a positional argument to "
             "builds(), but is only allowed as a keyword arg"
         )
     required = required_args(target, args, kwargs)
@@ -884,7 +891,8 @@ def builds(
         if to_infer - set(hints):
             badargs = ", ".join(sorted(to_infer - set(hints)))
             raise InvalidArgument(
-                f"passed infer for {badargs}, but there is no type annotation"
+                f"passed ... for {badargs}, but we cannot infer a strategy "
+                "because these arguments have no type annotation"
             )
         infer_for = {k: v for k, v in hints.items() if k in (required | to_infer)}
         if infer_for:
@@ -1864,7 +1872,7 @@ def functions(
 ) -> SearchStrategy[Callable[..., Any]]:
     # The proper type signature of `functions()` would have T instead of Any, but mypy
     # disallows default args for generics: https://github.com/python/mypy/issues/3737
-    """functions(*, like=lambda: None, returns=infer, pure=False)
+    """functions(*, like=lambda: None, returns=..., pure=False)
 
     A strategy for functions, which can be used in callbacks.
 

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

@@ -29,11 +29,11 @@
     import zoneinfo
 except ImportError:
     try:
-        from backports import zoneinfo
+        from backports import zoneinfo  # type: ignore
     except ImportError:
         # We raise an error recommending `pip install hypothesis[zoneinfo]`
         # when timezones() or timezone_keys() strategies are actually used.
-        zoneinfo = None
+        zoneinfo = None  # type: ignore
 
 DATENAMES = ("year", "month", "day")
 TIMENAMES = ("hour", "minute", "second", "microsecond")

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

@@ -39,9 +39,10 @@
 from hypothesis.strategies._internal.lazy import unwrap_strategies
 from hypothesis.strategies._internal.strategies import OneOfStrategy
 
+UnionType: typing.Any
 try:
     # The type of PEP-604 unions (`int | str`), added in Python 3.10
-    from types import UnionType  # type: ignore
+    from types import UnionType
 except ImportError:
     UnionType = ()
 
@@ -65,7 +66,7 @@
 
 TypeAliasTypes: tuple = ()
 try:
-    TypeAliasTypes += (typing.TypeAlias,)  # type: ignore
+    TypeAliasTypes += (typing.TypeAlias,)
 except AttributeError:
     pass  # Is missing for `python<3.10`
 try:
@@ -81,7 +82,7 @@
 
 FinalTypes: tuple = ()
 try:
-    FinalTypes += (typing.Final,)  # type: ignore
+    FinalTypes += (typing.Final,)
 except AttributeError:  # pragma: no cover
     pass  # Is missing for `python<3.8`
 try:
@@ -590,7 +591,7 @@ def _networks(bits):
     }
 )
 if hasattr(typing, "SupportsIndex"):  # pragma: no branch  # new in Python 3.8
-    _global_type_lookup[typing.SupportsIndex] = st.integers() | st.booleans()  # type: ignore
+    _global_type_lookup[typing.SupportsIndex] = st.integers() | st.booleans()
 
 
 def register(type_, fallback=None, *, module=typing):

hypothesis-python/src/hypothesis/utils/conventions.py

@@ -19,9 +19,5 @@ def __repr__(self):
         return self.identifier
 
 
-class InferType(UniqueIdentifier):
-    """We have a subclass for `infer` so we can type-hint public APIs."""
-
-
-infer = InferType("infer")
+infer = ...
 not_set = UniqueIdentifier("not_set")

hypothesis-python/tests/cover/test_attrs_inference.py

@@ -13,7 +13,7 @@
 import attr
 import pytest
 
-from hypothesis import given, infer, strategies as st
+from hypothesis import given, strategies as st
 from hypothesis.errors import ResolutionFailed
 
 
@@ -70,7 +70,7 @@ class UnhelpfulConverter:
     a = attr.ib(converter=lambda x: x)
 
 
-@given(st.builds(Inferrables, has_default=infer, has_default_factory=infer))
+@given(st.builds(Inferrables, has_default=..., has_default_factory=...))
 def test_attrs_inference_builds(c):
     pass
 
@@ -88,4 +88,4 @@ def test_cannot_infer(c):
 
 def test_cannot_infer_takes_self():
     with pytest.raises(ResolutionFailed):
-        st.builds(Inferrables, has_default_factory_takes_self=infer).example()
+        st.builds(Inferrables, has_default_factory_takes_self=...).example()

hypothesis-python/tests/cover/test_functions.py

@@ -12,7 +12,7 @@
 
 import pytest
 
-from hypothesis import assume, given, infer
+from hypothesis import assume, given
 from hypothesis.errors import InvalidArgument, InvalidState
 from hypothesis.strategies import booleans, functions, integers
 
@@ -112,7 +112,7 @@ def test_can_call_default_like_arg():
     # branch for calling it otherwise and alternative workarounds are worse.
     defaults = getfullargspec(functions).kwonlydefaults
     assert defaults["like"]() is None
-    assert defaults["returns"] is infer
+    assert defaults["returns"] is ...
 
 
 def func(arg, *, kwonly_arg):