Drops Python3.6 support, refs HypothesisWorks#3174

Author: sobolevn

.github/workflows/main.yml

@@ -23,8 +23,6 @@ jobs:
           - check-format
           - check-coverage
           - check-conjecture-coverage
-          - check-py36
-          - check-pypy36
           - check-py37
           - check-pypy37
           - check-py38

hypothesis-python/docs/strategies.rst

@@ -183,7 +183,7 @@ and then tell ``setuptools`` that this is your ``"hypothesis"`` entry point:
 And that's all it takes!
 
 .. note::
-    On Python 3.6 and 3.7, where the ``importlib.metadata`` module
+    On Python 3.7, where the ``importlib.metadata`` module
     is not in the standard library, loading entry points requires either the
     :pypi:`importlib_metadata` (preferred) or :pypi:`setuptools` (fallback)
     package to be installed.

hypothesis-python/docs/supported.rst

@@ -25,7 +25,7 @@ changes in patch releases.
 Python versions
 ---------------
 
-Hypothesis is supported and tested on CPython 3.6+, i.e.
+Hypothesis is supported and tested on CPython 3.7+, i.e.
 `all versions of CPython with upstream support <https://devguide.python.org/#status-of-python-branches>`_,
 along with PyPy for the same versions.
 32-bit builds of CPython also work, though we only test them on Windows.

hypothesis-python/examples/example_hypothesis_entrypoint/setup.py

@@ -25,7 +25,7 @@
     description="Minimal setup.py to register an entrypoint.",
     packages=setuptools.find_packages(),
     install_requires=["hypothesis"],
-    python_requires=">=3.6",
+    python_requires=">=3.7",
     entry_points={
         "hypothesis": ["_ = example_hypothesis_entrypoint:_hypothesis_setup_hook"]
     },

hypothesis-python/scripts/basic-test.sh

@@ -33,7 +33,7 @@ pip uninstall -y redis fakeredis
 
 pip install 'typing_extensions!=3.10.0.1'
 $PYTEST tests/typing_extensions/
-if [ "$(python -c 'import sys; print(sys.version_info[:2] <= (3, 7))')" = "False" ] ; then
+if [ "$(python -c 'import sys; print(sys.version_info[:2] == (3, 7))')" = "False" ] ; then
   # Required by importlib_metadata backport, which we don't want to break
   pip uninstall -y typing_extensions
 fi

hypothesis-python/setup.py

@@ -19,7 +19,7 @@
 
 import setuptools
 
-if sys.version_info[:2] < (3, 6):
+if sys.version_info[:2] < (3, 7):
     raise Exception(
         "This version of Python is too old to install new versions of Hypothesis.  "
         "Update `pip` and `setuptools`, try again, and you will automatically "
@@ -107,7 +107,7 @@ def local_file(name):
     zip_safe=False,
     extras_require=extras,
     install_requires=["attrs>=19.2.0", "sortedcontainers>=2.1.0,<3.0.0"],
-    python_requires=">=3.6",
+    python_requires=">=3.7",
     classifiers=[
         "Development Status :: 5 - Production/Stable",
         "Framework :: Hypothesis",
@@ -120,7 +120,6 @@ def local_file(name):
         "Programming Language :: Python",
         "Programming Language :: Python :: 3",
         "Programming Language :: Python :: 3 :: Only",
-        "Programming Language :: Python :: 3.6",
         "Programming Language :: Python :: 3.7",
         "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",

hypothesis-python/src/hypothesis/_error_if_old.py

@@ -18,11 +18,11 @@
 from hypothesis.version import __version__
 
 message = """
-Hypothesis {} requires Python 3.6 or later.
+Hypothesis {} requires Python 3.7 or later.
 
 This can only happen if your packaging toolchain is older than python_requires.
 See https://packaging.python.org/guides/distributing-packages-using-setuptools/
 """
 
-if sys.version_info[:3] < (3, 6):  # pragma: no cover
+if sys.version_info[:2] < (3, 7):  # pragma: no cover
     raise Exception(message.format(__version__))

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

@@ -329,52 +329,7 @@ def _strategy_for(
 def _get_params(func: Callable) -> Dict[str, inspect.Parameter]:
     """Get non-vararg parameters of `func` as an ordered dict."""
     var_param_kinds = (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD)
-    try:
-        params = list(inspect.signature(func).parameters.values())
-    except Exception:
-        if (
-            isinstance(func, (types.BuiltinFunctionType, types.BuiltinMethodType))
-            and hasattr(func, "__doc__")
-            and isinstance(func.__doc__, str)
-        ):
-            # inspect.signature doesn't work on all builtin functions or methods.
-            # In such cases, including the operator module on Python 3.6, we can try
-            # to reconstruct simple signatures from the docstring.
-            match = re.match(rf"^{func.__name__}\((.+?)\)", func.__doc__)
-            if match is None:
-                raise
-            args = match.group(1).replace("[", "").replace("]", "")
-            params = []
-            # Even if the signature doesn't contain a /, we assume that arguments
-            # are positional-only until shown otherwise - the / is often omitted.
-            kind: inspect._ParameterKind = inspect.Parameter.POSITIONAL_ONLY
-            for arg in args.split(", "):
-                arg, *_ = arg.partition("=")
-                if arg == "/":
-                    kind = inspect.Parameter.POSITIONAL_OR_KEYWORD
-                    continue
-                if arg.startswith("*"):
-                    kind = inspect.Parameter.KEYWORD_ONLY
-                    continue  # we omit *varargs, if there are any
-                if arg.startswith("**"):
-                    break  # and likewise omit **varkw
-                params.append(inspect.Parameter(name=arg, kind=kind))
-
-        elif _is_probably_ufunc(func):
-            # `inspect.signature` doesn't work on ufunc objects, but we can work out
-            # what the required parameters would look like if it did.
-            # Note that we use args named a, b, c... to match the `operator` module,
-            # rather than x1, x2, x3... like the Numpy docs.  Because they're pos-only
-            # this doesn't make a runtime difference, and it's much nicer for use-cases
-            # like `equivalent(numpy.add, operator.add)`.
-            params = [
-                inspect.Parameter(name=name, kind=inspect.Parameter.POSITIONAL_ONLY)
-                for name in ascii_lowercase[: func.nin]  # type: ignore
-            ]
-        else:
-            # If we haven't managed to recover a signature through the tricks above,
-            # we're out of ideas and should just re-raise the exception.
-            raise
+    params = list(inspect.signature(func).parameters.values())
     return OrderedDict((p.name, p) for p in params if p.kind not in var_param_kinds)
 
 
@@ -466,9 +421,6 @@ def _imports_for_object(obj):
         name = _get_qualname(obj).split(".")[0]
         return {(_get_module(obj), name)}
     except Exception:
-        with contextlib.suppress(AttributeError):
-            if obj.__module__ == "typing":  # only on CPython 3.6
-                return {("typing", getattr(obj, "__name__", obj.name))}
         return set()
 
 

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

@@ -1001,16 +1001,7 @@ def as_strategy(strat_or_callable, thing, final=True):
         # of it.  We do this in three places, hence the helper function
         if not isinstance(strat_or_callable, SearchStrategy):
             assert callable(strat_or_callable)  # Validated in register_type_strategy
-            try:
-                # On Python 3.6, typing.Hashable is just an alias for abc.Hashable,
-                # and the resolver function for Type throws an AttributeError because
-                # Hashable has no __args__.  We discard such errors when attempting
-                # to resolve subclasses, because the function was passed a weird arg.
-                strategy = strat_or_callable(thing)
-            except Exception:  # pragma: no cover
-                if not final:
-                    return nothing()
-                raise
+            strategy = strat_or_callable(thing)
         else:
             strategy = strat_or_callable
         if not isinstance(strategy, SearchStrategy):
@@ -1029,27 +1020,7 @@ def as_strategy(strat_or_callable, thing, final=True):
             if thing in types._global_type_lookup:
                 return as_strategy(types._global_type_lookup[thing], thing)
             return from_type(thing.__supertype__)
-        # Under Python 3.6, Unions are not instances of `type` - but we
-        # still want to resolve them!
-        if getattr(thing, "__origin__", None) is typing.Union:
-            args = sorted(thing.__args__, key=types.type_sorting_key)
-            return one_of([from_type(t) for t in args])
     if not types.is_a_type(thing):
-        # The implementation of typing_extensions.Literal under Python 3.6 is
-        # *very strange*.  Notably, `type(Literal[x]) != Literal` so we have to
-        # use the first form directly, and because it uses __values__ instead of
-        # __args__ we inline the relevant logic here until the end of life date.
-        if types.is_typing_literal(thing):  # pragma: no cover
-            assert sys.version_info[:2] == (3, 6)
-            args_dfs_stack = list(thing.__values__)  # type: ignore
-            literals = []
-            while args_dfs_stack:
-                arg = args_dfs_stack.pop()
-                if types.is_typing_literal(arg):
-                    args_dfs_stack.extend(reversed(arg.__values__))
-                else:
-                    literals.append(arg)
-            return sampled_from(literals)
         if isinstance(thing, str):
             # See https://github.com/HypothesisWorks/hypothesis/issues/3016
             raise InvalidArgument(
@@ -1060,7 +1031,7 @@ def as_strategy(strat_or_callable, thing, final=True):
             )
         raise InvalidArgument(f"thing={thing!r} must be a type")  # pragma: no cover
     # Now that we know `thing` is a type, the first step is to check for an
-    # explicitly registered strategy.  This is the best (and hopefully most
+    # explicitly registered strategy. This is the best (and hopefully most
     # common) way to resolve a type to a strategy.  Note that the value in the
     # lookup may be a strategy or a function from type -> strategy; and we
     # convert empty results into an explicit error.

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

@@ -396,8 +396,7 @@ def timezone_keys(
     .. note::
 
         The :mod:`python:zoneinfo` module is new in Python 3.9, so you will need
-        to install the :pypi:`backports.zoneinfo` module on earlier versions, and
-        the :pypi:`importlib_resources` backport on Python 3.6.
+        to install the :pypi:`backports.zoneinfo` module on earlier versions.
 
         `On Windows, you will also need to install the tzdata package
         <https://docs.python.org/3/library/zoneinfo.html#data-sources>`__.
@@ -457,8 +456,7 @@ def timezones(*, no_cache: bool = False) -> SearchStrategy["zoneinfo.ZoneInfo"]:
     .. note::
 
         The :mod:`python:zoneinfo` module is new in Python 3.9, so you will need
-        to install the :pypi:`backports.zoneinfo` module on earlier versions, and
-        the :pypi:`importlib_resources` backport on Python 3.6.
+        to install the :pypi:`backports.zoneinfo` module on earlier versions.
 
         `On Windows, you will also need to install the tzdata package
         <https://docs.python.org/3/library/zoneinfo.html#data-sources>`__.

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

@@ -49,11 +49,6 @@
 except ImportError:
     typing_extensions = None  # type: ignore
 
-try:
-    from typing import GenericMeta as _GenericMeta  # python < 3.7
-except ImportError:
-    _GenericMeta = ()  # type: ignore
-
 try:
     from typing import _GenericAlias  # type: ignore  # python >= 3.7
 except ImportError:
@@ -62,17 +57,7 @@
 try:
     from typing import _AnnotatedAlias  # type: ignore
 except ImportError:
-    try:
-        from typing_extensions import _AnnotatedAlias
-    except ImportError:
-        try:
-            from typing_extensions import (  # type: ignore
-                AnnotatedMeta as _AnnotatedAlias,
-            )
-
-            assert sys.version_info[:2] == (3, 6)
-        except ImportError:
-            _AnnotatedAlias = ()
+    from typing_extensions import _AnnotatedAlias
 
 
 def type_sorting_key(t):
@@ -111,9 +96,7 @@ def try_issubclass(thing, superclass):
             getattr(superclass, "__origin__", None) or superclass,
         ):
             superclass_args = getattr(superclass, "__args__", None)
-            if sys.version_info[:2] == (3, 6) or not superclass_args:
-                # Python 3.6 doesn't have PEP-560 semantics or __orig_bases__,
-                # so there's no point continuing; we therefore stop early.
+            if not superclass_args:
                 # The superclass is not generic, so we're definitely a subclass.
                 return True
             # Sadly this is just some really fiddly logic to handle all the cases
@@ -157,11 +140,7 @@ def is_typing_literal(thing):
         hasattr(typing, "Literal")
         and getattr(thing, "__origin__", None) == typing.Literal
         or hasattr(typing_extensions, "Literal")
-        and (
-            getattr(thing, "__origin__", None) == typing_extensions.Literal
-            or sys.version_info[:2] == (3, 6)
-            and isinstance(thing, type(typing_extensions.Literal[None]))
-        )
+        and getattr(thing, "__origin__", None) == typing_extensions.Literal
     )
 
 
@@ -190,7 +169,7 @@ def find_annotated_strategy(annotated_type):  # pragma: no cover
 def has_type_arguments(type_):
     """Decides whethere or not this type has applied type arguments."""
     args = getattr(type_, "__args__", None)
-    if args and isinstance(type_, (_GenericAlias, _GenericMeta)):
+    if args and isinstance(type_, _GenericAlias):
         # There are some cases when declared types do already have type arguments
         # Like `Sequence`, that is `_GenericAlias(abc.Sequence[T])[T]`
         parameters = getattr(type_, "__parameters__", None)
@@ -202,8 +181,7 @@ def has_type_arguments(type_):
 def is_generic_type(type_):
     """Decides whether a given type is generic or not."""
     # The ugly truth is that `MyClass`, `MyClass[T]`, and `MyClass[int]` are very different.
-    # In different python versions they might have the same type (3.6)
-    # or it can be regular type vs `_GenericAlias` (3.7+)
+    # In different python versions it can be regular type vs `_GenericAlias` (3.7+)
     # We check for `MyClass[T]` and `MyClass[int]` with the first condition,
     # while the second condition is for `MyClass` in `python3.7+`.
     return isinstance(type_, typing_root_type) or (
@@ -222,14 +200,6 @@ def _try_import_forward_ref(thing, bound):  # pragma: no cover
     try:
         return typing._eval_type(bound, vars(sys.modules[thing.__module__]), None)
     except (KeyError, AttributeError, NameError):
-        if (
-            isinstance(thing, typing.TypeVar)
-            and getattr(thing, "__module__", None) == "typing"
-        ):
-            raise ResolutionFailed(
-                "It looks like you're using a TypeVar bound to a ForwardRef on Python "
-                "3.6, which is not supported - try ugrading to Python 3.7 or later."
-            ) from None
         # We fallback to `ForwardRef` instance, you can register it as a type as well:
         # >>> from typing import ForwardRef
         # >>> from hypothesis import strategies as st
@@ -289,7 +259,6 @@ def from_typing_type(thing):
 
     # Some "generic" classes are not generic *in* anything - for example both
     # Hashable and Sized have `__args__ == ()` on Python 3.7 or later.
-    # (In 3.6 they're just aliases for the collections.abc classes)
     origin = getattr(thing, "__origin__", thing)
     if (
         typing.Hashable is not collections.abc.Hashable
@@ -310,9 +279,6 @@ def from_typing_type(thing):
         # ItemsView can cause test_lookup.py::test_specialised_collection_types
         # to fail, due to weird isinstance behaviour around the elements.
         mapping.pop(typing.ItemsView, None)
-        if sys.version_info[:2] == (3, 6):  # pragma: no cover
-            # `isinstance(dict().values(), Container) is False` on py36 only -_-
-            mapping.pop(typing.ValuesView, None)
     if typing.Deque in mapping and len(mapping) > 1:
         # Resolving generic sequences to include a deque is more trouble for e.g.
         # the ghostwriter than it's worth, via undefined names in the repr.
@@ -495,12 +461,10 @@ def _networks(bits):
 _global_type_lookup[type] = st.sampled_from(
     [type(None)] + sorted(_global_type_lookup, key=str)
 )
-
-if sys.version_info[:2] >= (3, 7):  # pragma: no branch
-    _global_type_lookup[re.Match] = (
-        st.text().map(lambda c: re.match(".", c, flags=re.DOTALL)).filter(bool)
-    )
-    _global_type_lookup[re.Pattern] = st.builds(re.compile, st.sampled_from(["", b""]))
+_global_type_lookup[re.Match] = (
+    st.text().map(lambda c: re.match(".", c, flags=re.DOTALL)).filter(bool)
+)
+_global_type_lookup[re.Pattern] = st.builds(re.compile, st.sampled_from(["", b""]))
 if sys.version_info[:2] >= (3, 9):  # pragma: no cover
     # subclass of MutableMapping, and in Python 3.9 we resolve to a union
     # which includes this... but we don't actually ever want to build one.

hypothesis-python/tests/conftest.py

@@ -31,8 +31,6 @@
 # Skip collection of tests which require the Django test runner,
 # or that don't work on the current version of Python.
 collect_ignore_glob = ["django/*"]
-if sys.version_info < (3, 7):
-    collect_ignore_glob.append("cover/*py37*")
 if sys.version_info < (3, 8):
     collect_ignore_glob.append("array_api")
     collect_ignore_glob.append("cover/*py38*")

hypothesis-python/tests/cover/test_async_def.py

@@ -14,11 +14,8 @@
 # END HEADER
 
 import asyncio
-import sys
 from unittest import TestCase
 
-import pytest
-
 from hypothesis import assume, given, strategies as st
 
 
@@ -29,7 +26,6 @@ class TestAsyncioRun(TestCase):
     def execute_example(self, f):
         asyncio.run(f())
 
-    @pytest.mark.skipif(sys.version_info[:2] < (3, 7), reason="asyncio.run() is new")
     @given(st.text())
     async def test_foo(self, x):
         assume(x)

hypothesis-python/tests/cover/test_datetimes.py

@@ -18,7 +18,6 @@
 import pytest
 
 from hypothesis import given, settings
-from hypothesis.internal.compat import PYPY
 from hypothesis.strategies import dates, datetimes, timedeltas, times
 
 from tests.common.debug import find_any, minimal
@@ -139,13 +138,10 @@ def test_naive_times_are_naive(dt):
     assert dt.tzinfo is None
 
 
-# pypy3.6 seems to canonicalise fold to 0 for non-ambiguous times?
-@pytest.mark.skipif(PYPY, reason="see comment")
 def test_can_generate_datetime_with_fold_1():
     find_any(datetimes(), lambda d: d.fold)
 
 
-@pytest.mark.skipif(PYPY, reason="see comment")
 def test_can_generate_time_with_fold_1():
     find_any(times(), lambda d: d.fold)