Compat cleanup in other modules

Various issues found by grepping for Python 2 comments and nocover pragmas.

Author: Zac-HD

.flake8

@@ -1,7 +1,6 @@
 [flake8]
 
 exclude =
-    hypothesis-python/src/hypothesis/vendor/*,
     test_reflection.py,
     test_imports.py,
     test_lambda_formatting.py

hypothesis-python/.coveragerc

@@ -22,4 +22,3 @@ exclude_lines =
     __deepcopy__
     except ImportError:
     assert all\(.+\)
-    if __reserved is not not_set:

hypothesis-python/src/hypothesis/_settings.py

@@ -627,7 +627,7 @@ def _validate_deadline(x):
 settings.lock_further_definitions()
 
 
-def note_deprecation(message, since):
+def note_deprecation(message, *, since):
     # type: (str, str) -> None
     if since != "RELEASEDAY":
         date = datetime.datetime.strptime(since, "%Y-%m-%d").date()

hypothesis-python/src/hypothesis/control.py

@@ -168,7 +168,7 @@ def target(observation, label=""):
     example shrinks right down to the threshold of failure (:issue:`2180`).
     """
     check_type(float, observation, "observation")
-    if math.isinf(observation) or math.isnan(observation):
+    if not math.isfinite(observation):
         raise InvalidArgument("observation=%r must be a finite float." % observation)
     check_type(str, label, "label")
 

hypothesis-python/src/hypothesis/core.py

@@ -276,12 +276,6 @@ def wrapped_test(*arguments, **kwargs):
             "%s() got an unexpected keyword argument %r, from `%s=%r` in @given"
             % (name, arg, arg, given_kwargs[arg])
         )
-    for a in original_argspec.args:
-        if isinstance(a, list):  # pragma: no cover
-            return invalid(
-                "Cannot decorate function %s() because it has destructuring arguments"
-                % (name,)
-            )
     if original_argspec.defaults or original_argspec.kwonlydefaults:
         return invalid("Cannot apply @given to a function with defaults.")
     missing = [repr(kw) for kw in original_argspec.kwonlyargs if kw not in given_kwargs]

hypothesis-python/src/hypothesis/database.py

@@ -177,10 +177,7 @@ def save(self, key, value):
         mkdir_p(self._key_path(key))
         path = self._value_path(key, value)
         if not os.path.exists(path):
-            suffix = binascii.hexlify(os.urandom(16))
-            if not isinstance(suffix, str):  # pragma: no branch
-                # On Python 3, binascii.hexlify returns bytes
-                suffix = suffix.decode("ascii")
+            suffix = binascii.hexlify(os.urandom(16)).decode("ascii")
             tmpname = path + "." + suffix
             with open(tmpname, "wb") as o:
                 o.write(value)

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

@@ -25,7 +25,7 @@
 from hypothesis import assume
 from hypothesis.errors import InvalidArgument
 from hypothesis.internal.coverage import check_function
-from hypothesis.internal.reflection import proxies, reserved_means_kwonly_star
+from hypothesis.internal.reflection import proxies
 from hypothesis.internal.validation import check_type, check_valid_interval
 from hypothesis.strategies._internal import SearchStrategy
 from hypothesis.utils.conventions import UniqueIdentifier, not_set
@@ -1023,16 +1023,15 @@ def _hypothesis_parse_gufunc_signature(signature, all_checks=True):
 
 
 @st.defines_strategy
-@reserved_means_kwonly_star
 def mutually_broadcastable_shapes(
-    __reserved=not_set,  # type: Any
+    *,
     num_shapes=not_set,  # type: Union[UniqueIdentifier, int]
     signature=not_set,  # type: Union[UniqueIdentifier, str]
     base_shape=(),  # type: Shape
     min_dims=0,  # type: int
     max_dims=None,  # type: int
     min_side=1,  # type: int
-    max_side=None,  # type: int
+    max_side=None  # type: int
 ):
     # type: (...) -> st.SearchStrategy[BroadcastableShapes]
     """Return a strategy for generating a specified number of shapes, N, that are
@@ -1108,9 +1107,6 @@ def mutually_broadcastable_shapes(
         BroadcastableShapes(input_shapes=((3, 4, 2), (1, 2)), result_shape=(3, 4))
         BroadcastableShapes(input_shapes=((4, 2), (1, 2, 3)), result_shape=(4, 3))
     """
-    if __reserved is not not_set:
-        raise InvalidArgument("Do not pass the __reserved argument.")
-
     arg_msg = "Pass either the `num_shapes` or the `signature` argument, but not both."
     if num_shapes is not not_set:
         check_argument(signature is not_set, arg_msg)
@@ -1251,16 +1247,10 @@ def do_draw(self, data):
 
 
 @st.defines_strategy
-@reserved_means_kwonly_star
 def basic_indices(
-    shape,
-    __reserved=not_set,
-    min_dims=0,
-    max_dims=None,
-    allow_newaxis=False,
-    allow_ellipsis=True,
+    shape, *, min_dims=0, max_dims=None, allow_newaxis=False, allow_ellipsis=True
 ):
-    # type: (Shape, Any, int, int, bool, bool) -> st.SearchStrategy[BasicIndex]
+    # type: (Shape, int, int, bool, bool) -> st.SearchStrategy[BasicIndex]
     """
     The ``basic_indices`` strategy generates `basic indexes
     <https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html>`__  for
@@ -1288,10 +1278,8 @@ def basic_indices(
     # Arguments to exclude scalars, zero-dim arrays, and dims of size zero were
     # all considered and rejected.  We want users to explicitly consider those
     # cases if they're dealing in general indexers, and while it's fiddly we can
-    # back-compatibly add them later (hence using __reserved to sim kwonlyargs).
+    # back-compatibly add them later (hence using kwonlyargs).
     check_type(tuple, shape, "shape")
-    if __reserved is not not_set:
-        raise InvalidArgument("Do not pass the __reserved argument.")
     check_type(bool, allow_ellipsis, "allow_ellipsis")
     check_type(bool, allow_newaxis, "allow_newaxis")
     check_type(int, min_dims, "min_dims")

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

@@ -13,7 +13,7 @@
 #
 # END HEADER
 
-from math import fabs, isinf, isnan, sqrt
+from math import fabs, inf, isinf, isnan, nan, sqrt
 from sys import float_info
 
 
@@ -35,21 +35,21 @@ def cathetus(h, a):
     Based on the C99 implementation https://github.com/jjgreen/cathetus
     """
     if isnan(h):
-        return float("nan")
+        return nan
 
     if isinf(h):
         if isinf(a):
-            return float("nan")
+            return nan
         else:
             # Deliberately includes the case when isnan(a), because the
             # C99 standard mandates that hypot(inf, nan) == inf
-            return float("inf")
+            return inf
 
     h = fabs(h)
     a = fabs(a)
 
     if h < a:
-        return float("nan")
+        return nan
 
     # Thanks to floating-point precision issues when performing multiple
     # operations on extremely large or small values, we may rarely calculate

hypothesis-python/src/hypothesis/internal/conjecture/shrinking/floats.py

@@ -25,7 +25,7 @@
 
 class Float(Shrinker):
     def setup(self):
-        self.NAN = float("nan")
+        self.NAN = math.nan
         self.debugging_enabled = True
 
     def make_immutable(self, f):
@@ -46,11 +46,11 @@ def left_is_better(self, left, right):
         return lex1 < lex2
 
     def short_circuit(self):
-        for g in [sys.float_info.max, float("inf"), float("nan")]:
+        for g in [sys.float_info.max, math.inf, math.nan]:
             self.consider(g)
 
-        # If we're stuck at a nasty float don't try to shrink it further. These
-        if math.isinf(self.current) or math.isnan(self.current):
+        # If we're stuck at a nasty float don't try to shrink it further.
+        if not math.isfinite(self.current):
             return True
 
         # If its too large to represent as an integer, bail out here. It's

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

@@ -22,6 +22,7 @@
 import re
 import types
 from functools import wraps
+from tokenize import detect_encoding
 from types import ModuleType
 
 from hypothesis.internal.compat import (
@@ -32,11 +33,6 @@
 )
 from hypothesis.vendor.pretty import pretty
 
-try:
-    from tokenize import detect_encoding
-except ImportError:  # pragma: no cover
-    detect_encoding = None
-
 if False:
     from typing import TypeVar  # noqa
 
@@ -266,17 +262,9 @@ def extract_lambda_source(f):
     """
     argspec = inspect.getfullargspec(f)
     arg_strings = []
-    # In Python 2 you can have destructuring arguments to functions. This
-    # results in an argspec with non-string values. I'm not very interested in
-    # handling these properly, but it's important to not crash on them.
-    bad_lambda = False
     for a in argspec.args:
-        if isinstance(a, (tuple, list)):  # pragma: no cover
-            arg_strings.append("(%s)" % (", ".join(a),))
-            bad_lambda = True
-        else:
-            assert isinstance(a, str)
-            arg_strings.append(a)
+        assert isinstance(a, str)
+        arg_strings.append(a)
     if argspec.varargs:
         arg_strings.append("*" + argspec.varargs)
     elif argspec.kwonlyargs:
@@ -292,8 +280,6 @@ def extract_lambda_source(f):
         if_confused = "lambda %s: <unknown>" % (", ".join(arg_strings),)
     else:
         if_confused = "lambda: <unknown>"
-    if bad_lambda:  # pragma: no cover
-        return if_confused
     try:
         source = inspect.getsource(f)
     except OSError:
@@ -363,13 +349,6 @@ def extract_lambda_source(f):
     # an OSError.  Or if `f` is a built-in function, in which case we get a
     # TypeError.  In both cases, fall back to splitting the Unicode string.
     # It's not perfect, but it's the best we can do.
-    #
-    # Note 2: You can only detect the encoding with `tokenize.detect_encoding`
-    # in Python 3.2 or later.  But that's okay, because the only version that
-    # affects for us is Python 2.7, and 2.7 doesn't support non-ASCII identifiers:
-    # https://www.python.org/dev/peps/pep-3131/. In this case we'll get an
-    # TypeError again because we set detect_encoding to None above.
-    #
     try:
         with open(inspect.getsourcefile(f), "rb") as src_f:
             encoding, _ = detect_encoding(src_f.readline)
@@ -612,35 +591,3 @@ def accept(proxy):
         )
 
     return accept
-
-
-def reserved_means_kwonly_star(func):
-    # type: (C) -> C
-    """A decorator to implement Python-2-compatible kwonly args.
-
-    The following functions behave identically:
-        def f(a, __reserved=not_set, b=None): ...
-        def f(a, *, b=None): ...
-
-    Obviously this doesn't allow required kwonly args, but it's a nice way
-    of defining forward-compatible APIs given our plans to turn all args
-    with default values into kwonly args.
-    """
-    signature = inspect.signature(func)
-    seen = False
-    parameters = []
-    for param in signature.parameters.values():
-        assert param.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD
-        if param.name == "__reserved":
-            seen = True
-        elif not seen:
-            parameters.append(param)
-        else:
-            parameters.append(param.replace(kind=inspect.Parameter.KEYWORD_ONLY))
-    assert seen, "function does not have `__reserved` argument"
-
-    func.__signature__ = signature.replace(parameters=parameters)
-    newsig = define_function_signature(
-        func.__name__, func.__doc__, inspect.getfullargspec(func)
-    )
-    return impersonate(func)(wraps(func)(newsig(func)))

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

@@ -54,7 +54,6 @@
     nicerepr,
     proxies,
     required_args,
-    reserved_means_kwonly_star,
 )
 from hypothesis.internal.validation import (
     check_type,
@@ -430,7 +429,7 @@ def floats(
     Excluding either signed zero will also exclude the other.
     Attempting to exclude an endpoint which is None will raise an error;
     use ``allow_infinity=False`` to generate finite floats.  You can however
-    use e.g. ``min_value=float("-inf"), exclude_min=True`` to exclude only
+    use e.g. ``min_value=-math.inf, exclude_min=True`` to exclude only
     one infinite endpoint.
 
     Examples from this strategy have a complicated and hard to explain
@@ -481,9 +480,9 @@ def floats(
             "%d - use max_value=%r instead" % (max_arg, width, max_value)
         )
 
-    if exclude_min and (min_value is None or min_value == float("inf")):
+    if exclude_min and (min_value is None or min_value == math.inf):
         raise InvalidArgument("Cannot exclude min_value=%r" % (min_value,))
-    if exclude_max and (max_value is None or max_value == float("-inf")):
+    if exclude_max and (max_value is None or max_value == -math.inf):
         raise InvalidArgument("Cannot exclude max_value=%r" % (max_value,))
 
     if min_value is not None and (
@@ -505,9 +504,9 @@ def floats(
             max_value = next_down(max_value, width)
         assert max_value < max_arg  # type: ignore
 
-    if min_value == float("-inf"):
+    if min_value == -math.inf:
         min_value = None
-    if max_value == float("inf"):
+    if max_value == math.inf:
         max_value = None
 
     bad_zero_bounds = (
@@ -538,9 +537,9 @@ def floats(
                 "Cannot have allow_infinity=%r, with both min_value and "
                 "max_value" % (allow_infinity)
             )
-    elif min_value == float("inf"):
+    elif min_value == math.inf:
         raise InvalidArgument("allow_infinity=False excludes min_value=inf")
-    elif max_value == float("-inf"):
+    elif max_value == -math.inf:
         raise InvalidArgument("allow_infinity=False excludes max_value=-inf")
 
     unbounded_floats = FloatStrategy(
@@ -837,11 +836,10 @@ def iterables(
 
 
 @defines_strategy
-@reserved_means_kwonly_star
 def fixed_dictionaries(
     mapping,  # type: Dict[T, SearchStrategy[Ex]]
-    __reserved=not_set,  # type: Any
-    optional=None,  # type: Dict[T, SearchStrategy[Ex]]
+    *,
+    optional=None  # type: Dict[T, SearchStrategy[Ex]]
 ):
     # type: (...) -> SearchStrategy[Dict[T, Ex]]
     """Generates a dictionary of the same type as mapping with a fixed set of
@@ -858,8 +856,6 @@ def fixed_dictionaries(
     check_type(dict, mapping, "mapping")
     for k, v in mapping.items():
         check_strategy(v, "mapping[%r]" % (k,))
-    if __reserved is not not_set:
-        raise InvalidArgument("Do not pass __reserved; got %r" % (__reserved,))
     if optional is not None:
         check_type(dict, optional, "optional")
         for k, v in optional.items():
@@ -1915,7 +1911,7 @@ def complex_numbers(
     check_valid_magnitude(min_magnitude, "min_magnitude")
     check_valid_magnitude(max_magnitude, "max_magnitude")
     check_valid_interval(min_magnitude, max_magnitude, "min_magnitude", "max_magnitude")
-    if max_magnitude == float("inf"):
+    if max_magnitude == math.inf:
         max_magnitude = None
     if min_magnitude == 0:
         min_magnitude = None

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

@@ -78,7 +78,7 @@ def do_draw(self, data):
         1.192092896e-07,
         2.2204460492503131e-016,
     ]
-    + [float("inf"), float("nan")] * 5,
+    + [math.inf, math.nan] * 5,
     key=flt.float_to_lex,
 )
 NASTY_FLOATS = list(map(float, NASTY_FLOATS))

hypothesis-python/src/hypothesis/vendor/__init__.py

@@ -1,7 +1,7 @@
 # This file is part of Hypothesis, which may be found at
 # https://github.com/HypothesisWorks/hypothesis/
 #
-# Most of this work is copyright (C) 2013-2019 David R. MacIver
+# Most of this work is copyright (C) 2013-2020 David R. MacIver
 # (david@drmaciver.com), but it contains contributions by others. See
 # CONTRIBUTING.rst for a full list of people who may hold copyright, and
 # consult the git log if you need to determine who owns an individual