Add flake8-comprehensions

Author: Zac-HD

hypothesis-python/RELEASE.rst

@@ -0,0 +1,5 @@
+RELEASE_TYPE: patch
+
+This patch adds :pypi:`flake8-comprehensions` to our linter suite.  There is no
+user-visible change - expect perhaps via some strange microbenchmarks - but
+certain parts of the code now have a clear and more consistent style.

hypothesis-python/src/hypothesis/_strategies.py

@@ -1017,7 +1017,7 @@ def characters(
             "Nothing is excluded by other arguments, so passing only "
             "whitelist_characters=%(chars)r would have no effect.  Also pass "
             "whitelist_categories=(), or use sampled_from(%(chars)r) instead."
-            % dict(chars=whitelist_characters)
+            % {"chars": whitelist_characters}
         )
     blacklist_characters = blacklist_characters or ""
     whitelist_characters = whitelist_characters or ""
@@ -2017,7 +2017,7 @@ def complex_numbers(
             "Cannot have allow_nan=%r, min_magnitude=%r max_magnitude=%r"
             % (allow_nan, min_magnitude, max_magnitude)
         )
-    allow_kw = dict(allow_nan=allow_nan, allow_infinity=allow_infinity)
+    allow_kw = {"allow_nan": allow_nan, "allow_infinity": allow_infinity}
 
     if min_magnitude is None and max_magnitude is None:
         # In this simple but common case, there are no constraints on the

hypothesis-python/src/hypothesis/core.py

@@ -700,7 +700,7 @@ def run_engine(self):
             return
         if runner.interesting_examples:
             self.falsifying_examples = sorted(
-                [d for d in runner.interesting_examples.values()],
+                runner.interesting_examples.values(),
                 key=lambda d: sort_key(d.buffer),
                 reverse=True,
             )

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

@@ -63,7 +63,7 @@ def timezones():
     information.
     """
     all_timezones = sorted(
-        [tz.gettz(t) for t in zoneinfo.get_zonefile_instance().zones],
+        (tz.gettz(t) for t in zoneinfo.get_zonefile_instance().zones),
         key=__zone_sort_key,
     )
     all_timezones.insert(0, tz.UTC)

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

@@ -136,11 +136,11 @@ def _for_slug(field):
 
 @register_for(dm.GenericIPAddressField)
 def _for_model_ip(field):
-    return dict(
-        ipv4=ip4_addr_strings(),
-        ipv6=ip6_addr_strings(),
-        both=ip4_addr_strings() | ip6_addr_strings(),
-    )[field.protocol.lower()]
+    return {
+        "ipv4": ip4_addr_strings(),
+        "ipv6": ip6_addr_strings(),
+        "both": ip4_addr_strings() | ip6_addr_strings(),
+    }[field.protocol.lower()]
 
 
 @register_for(df.GenericIPAddressField)

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

@@ -102,9 +102,9 @@ def charmap():
         # and that both elements of that tuple are integers.
         for vs in _charmap.values():
             ints = list(sum(vs, ()))
-            assert all([isinstance(x, int) for x in ints])
+            assert all(isinstance(x, int) for x in ints)
             assert ints == sorted(ints)
-            assert all([len(tup) == 2 for tup in vs])
+            assert all(len(tup) == 2 for tup in vs)
 
     assert _charmap is not None
     return _charmap

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

@@ -46,7 +46,7 @@ def __init__(self, min_value, max_value, timezones_strat):
         self.tz_strat = timezones_strat
 
     def do_draw(self, data):
-        result = dict()
+        result = {}
         cap_low, cap_high = True, True
         for name in ("year", "month", "day", "hour", "minute", "second", "microsecond"):
             low = getattr(self.min_dt if cap_low else dt.datetime.min, name)
@@ -96,7 +96,7 @@ def __init__(self, min_value, max_value):
         self.max_value = max_value
 
     def do_draw(self, data):
-        result = dict()
+        result = {}
         low_bound = True
         high_bound = True
         for name in ("days", "seconds", "microseconds"):

hypothesis-python/tests/cover/test_attrs_inference.py

@@ -70,7 +70,7 @@ class Inferrables(object):
     has_default = attr.ib(default=0)
     has_default_factory = attr.ib(default=attr.Factory(list))
     has_default_factory_takes_self = attr.ib(  # uninferrable but has default
-        default=attr.Factory(lambda _: list(), takes_self=True)
+        default=attr.Factory(lambda _: [], takes_self=True)
     )
 
 

hypothesis-python/tests/cover/test_feature_flags.py

@@ -45,7 +45,7 @@ def test_minimizes_individual_features_to_open():
     features = list(hrange(10))
 
     flags = minimal(
-        STRAT, lambda x: sum([x.is_enabled(i) for i in features]) < len(features)
+        STRAT, lambda x: sum(x.is_enabled(i) for i in features) < len(features)
     )
 
     assert all(flags.is_enabled(i) for i in features[:-1])

hypothesis-python/tests/cover/test_float_nastiness.py

@@ -211,14 +211,14 @@ def test_float16_can_exclude_infinity(x):
 @pytest.mark.parametrize(
     "kwargs",
     [
-        dict(min_value=10 ** 5, width=16),
-        dict(max_value=10 ** 5, width=16),
-        dict(min_value=10 ** 40, width=32),
-        dict(max_value=10 ** 40, width=32),
-        dict(min_value=10 ** 400, width=64),
-        dict(max_value=10 ** 400, width=64),
-        dict(min_value=10 ** 400),
-        dict(max_value=10 ** 400),
+        {"min_value": 10 ** 5, "width": 16},
+        {"max_value": 10 ** 5, "width": 16},
+        {"min_value": 10 ** 40, "width": 32},
+        {"max_value": 10 ** 40, "width": 32},
+        {"min_value": 10 ** 400, "width": 64},
+        {"max_value": 10 ** 400, "width": 64},
+        {"min_value": 10 ** 400},
+        {"max_value": 10 ** 400},
     ],
 )
 def test_out_of_range(kwargs):

hypothesis-python/tests/cover/test_settings.py

@@ -466,11 +466,11 @@ def test_derandomise_with_explicit_database_is_invalid():
 @pytest.mark.parametrize(
     "kwargs",
     [
-        dict(max_examples=-1),
-        dict(buffer_size=-1),
-        dict(stateful_step_count=-1),
-        dict(deadline=-1),
-        dict(deadline=0),
+        {"max_examples": -1},
+        {"buffer_size": -1},
+        {"stateful_step_count": -1},
+        {"deadline": -1},
+        {"deadline": 0},
     ],
 )
 def test_invalid_settings_are_errors(kwargs):

hypothesis-python/tests/cover/test_simple_collections.py

@@ -152,7 +152,10 @@ def test_can_find_unique_lists_of_non_set_order():
     # a consistent value. This could be 0, or it could be the PYTHONHASHSEED
     # value listed in a failure log from CI.
 
-    ls = minimal(lists(text(), unique=True), lambda x: list(set(reversed(x))) != x)
+    ls = minimal(
+        lists(text(), unique=True),
+        lambda x: list(set(reversed(x))) != x,  # noqa: C414  # yes, reverse inside set
+    )
     assert len(set(ls)) == len(ls)
     assert len(ls) == 2
 

hypothesis-python/tests/cover/test_type_lookup.py

@@ -222,7 +222,7 @@ def test_uninspectable_from_type():
 
 
 @pytest.mark.parametrize(
-    "typ", sorted([x for x in _global_type_lookup if x.__module__ != "typing"], key=str)
+    "typ", sorted((x for x in _global_type_lookup if x.__module__ != "typing"), key=str)
 )
 @given(data=st.data())
 def test_can_generate_from_all_registered_types(data, typ):

hypothesis-python/tests/nocover/test_from_type_recipe.py

@@ -21,6 +21,8 @@
 from hypothesis import given
 from hypothesis.searchstrategy.types import _global_type_lookup
 
+TYPES = sorted((x for x in _global_type_lookup if x.__module__ != "typing"), key=str)
+
 
 def everything_except(excluded_types):
     """Recipe copied from the docstring of ``from_type``"""
@@ -33,14 +35,7 @@ def everything_except(excluded_types):
 
 @given(
     excluded_types=st.lists(
-        st.sampled_from(
-            sorted(
-                [x for x in _global_type_lookup if x.__module__ != "typing"], key=str
-            )
-        ),
-        min_size=1,
-        max_size=3,
-        unique=True,
+        st.sampled_from(TYPES), min_size=1, max_size=3, unique=True,
     ).map(tuple),
     data=st.data(),
 )

hypothesis-python/tests/nocover/test_pretty_repr.py

@@ -52,11 +52,10 @@ def splat(value):
     return st.tuples(st.tuples(*args), st.fixed_dictionaries(kwargs)).map(splat)
 
 
-size_strategies = dict(
-    min_size=st.integers(min_value=0, max_value=100),
-    max_size=st.integers(min_value=0, max_value=100) | st.none(),
-)
-
+size_strategies = {
+    "min_size": st.integers(min_value=0, max_value=100),
+    "max_size": st.integers(min_value=0, max_value=100) | st.none(),
+}
 
 values = st.integers() | st.text()
 

hypothesis-python/tests/numpy/test_argument_validation.py

@@ -313,7 +313,7 @@ def test_test_basic_indices_kwonly_emulation():
         nps.basic_indices((), __reserved=None).validate()
 
 
-@pytest.mark.parametrize("args", ({}, (1,), dict(num_shapes=1, __reserved=None)))
+@pytest.mark.parametrize("args", ({}, (1,), {"num_shapes": 1, "__reserved": None}))
 def test_test_mutually_broadcastable_shapes_kwonly_emulation(args):
     with pytest.raises(TypeError):
         if isinstance(args, dict):

hypothesis-python/tests/numpy/test_gen_data.py

@@ -192,7 +192,7 @@ def test_minimise_array_shapes(min_dims, dim_range, min_side, side_range):
 
 
 @pytest.mark.parametrize(
-    "kwargs", [dict(min_side=100), dict(min_dims=15), dict(min_dims=32)]
+    "kwargs", [{"min_side": 100}, {"min_dims": 15}, {"min_dims": 32}]
 )
 def test_interesting_array_shapes_argument(kwargs):
     nps.array_shapes(**kwargs).example()
@@ -453,9 +453,9 @@ def test_all_inferred_scalar_strategies_roundtrip(data, dtype):
 @checks_deprecated_behaviour
 @given(st.data())
 def test_overflowing_integers_are_deprecated(fill, data):
-    kw = dict(elements=st.just(300))
+    kw = {"elements": st.just(300)}
     if fill:
-        kw = dict(elements=st.nothing(), fill=kw["elements"])
+        kw = {"elements": st.nothing(), "fill": kw["elements"]}
     arr = data.draw(nps.arrays(dtype="int8", shape=(1,), **kw))
     assert arr[0] == (300 % 256)
 
@@ -475,9 +475,9 @@ def test_overflowing_integers_are_deprecated(fill, data):
 @given(data=st.data())
 def test_unrepresentable_elements_are_deprecated(fill, dtype, strat, data):
     if fill:
-        kw = dict(elements=st.nothing(), fill=strat)
+        kw = {"elements": st.nothing(), "fill": strat}
     else:
-        kw = dict(elements=strat)
+        kw = {"elements": strat}
     arr = data.draw(nps.arrays(dtype=dtype, shape=(1,), **kw))
     try:
         # This is a float or complex number, and has overflowed to infinity,
@@ -992,7 +992,7 @@ def test_mutually_broadcastable_shapes_only_singleton_is_valid(
     assert len(input_shapes) == num_shapes
     assert result == _broadcast_shapes(base_shape, *input_shapes)
     for shape in input_shapes:
-        assert all([i == 1 for i in shape[-len(base_shape) :]])
+        assert all(i == 1 for i in shape[-len(base_shape) :])
 
 
 @settings(deadline=None)
@@ -1007,11 +1007,10 @@ def test_broadcastable_shape_can_generate_arbitrary_ndims(shape, max_dims, data)
     min_dims = data.draw(
         st.one_of(st.none(), st.integers(0, desired_ndim)), label="min_dims"
     )
-    args = (
-        dict(min_dims=min_dims) if min_dims is not None else {}
-    )  # check default arg behavior too
+    # check default arg behavior too
+    kwargs = {"min_dims": min_dims} if min_dims is not None else {}
     find_any(
-        nps.broadcastable_shapes(shape, min_side=0, max_dims=max_dims, **args),
+        nps.broadcastable_shapes(shape, min_side=0, max_dims=max_dims, **kwargs),
         lambda x: len(x) == desired_ndim,
         settings(max_examples=10 ** 6),
     )
@@ -1035,16 +1034,15 @@ def test_mutually_broadcastable_shapes_can_generate_arbitrary_ndims(
     min_dims = data.draw(
         st.one_of(st.none(), st.integers(0, min(desired_ndims))), label="min_dims"
     )
-    args = (
-        dict(min_dims=min_dims) if min_dims is not None else {}
-    )  # check default arg behavior too
+    # check default arg behavior too
+    kwargs = {"min_dims": min_dims} if min_dims is not None else {}
     find_any(
         nps.mutually_broadcastable_shapes(
             num_shapes=num_shapes,
             base_shape=base_shape,
             min_side=0,
             max_dims=max_dims,
-            **args
+            **kwargs
         ),
         lambda x: {len(s) for s in x.input_shapes} == set(desired_ndims),
         settings(max_examples=10 ** 6),

hypothesis-python/tests/py3/test_annotations.py

@@ -87,16 +87,16 @@ def test_converter_handles_kwonly_args():
     def f(*, a, b=2):
         pass
 
-    out = convert_positional_arguments(f, (), dict(a=1))
-    assert out == ((), dict(a=1, b=2))
+    out = convert_positional_arguments(f, (), {"a": 1})
+    assert out == ((), {"a": 1, "b": 2})
 
 
 def test_converter_notices_missing_kwonly_args():
     def f(*, a, b=2):
         pass
 
     with pytest.raises(TypeError):
-        assert convert_positional_arguments(f, (), dict())
+        assert convert_positional_arguments(f, (), {})
 
 
 def pointless_composite(draw: None, strat: bool, nothing: list) -> int:

hypothesis-python/tests/py3/test_lookup.py

@@ -437,9 +437,9 @@ def method(self, a: int, b: int):
         ((), {}),
         ((1,), {}),
         ((1, 2), {}),
-        ((), dict(a=1)),
-        ((), dict(b=2)),
-        ((), dict(a=1, b=2)),
+        ((), {"a": 1}),
+        ((), {"b": 2}),
+        ((), {"a": 1, "b": 2}),
     ],
 )
 def test_required_args(target, args, kwargs):

hypothesis-python/tests/quality/test_integers.py

@@ -118,9 +118,7 @@ def f(data):
     #   have power of two sizes, so it may be up to a factor of two more than
     #   that.
     bits_needed = 1 + n.bit_length()
-    actual_bits_needed = min(
-        [s for s in WideRangeIntStrategy.sizes if s >= bits_needed]
-    )
+    actual_bits_needed = min(s for s in WideRangeIntStrategy.sizes if s >= bits_needed)
     bytes_needed = actual_bits_needed // 8
     # 3 extra bytes: two for the sampler, one for the capping value.
     assert len(v.buffer) == 3 + bytes_needed

hypothesis-python/tests/quality/test_shrink_quality.py

@@ -325,7 +325,7 @@ def test_can_find_sets_unique_by_incomplete_data():
         lists(tuples(integers(), integers()), unique_by=max), lambda x: len(x) >= size
     )
     assert len(ls) == size
-    values = sorted(list(map(max, ls)))
+    values = sorted(map(max, ls))
     assert values[-1] - values[0] == size - 1
     for u, _ in ls:
         assert u <= 0

requirements/tools.in

@@ -9,6 +9,7 @@ flake8
 flake8-alfred
 flake8-bandit
 flake8-bugbear
+flake8-comprehensions
 flake8-docstrings
 ipython
 isort

requirements/tools.txt

@@ -30,14 +30,15 @@ filelock==3.0.12          # via tox
 flake8-alfred==1.1.1
 flake8-bandit==2.1.2
 flake8-bugbear==19.8.0
+flake8-comprehensions==3.1.4
 flake8-docstrings==1.5.0
 flake8-polyfill==1.0.2    # via flake8-bandit
 flake8==3.7.9
 gitdb2==2.0.6             # via gitpython
 gitpython==3.0.4          # via bandit
 idna==2.8                 # via requests
 imagesize==1.1.0          # via sphinx
-importlib-metadata==0.23  # via pluggy, pytest, tox
+importlib-metadata==0.23  # via flake8-comprehensions, pluggy, pytest, tox
 ipython-genutils==0.2.0   # via traitlets
 ipython==7.9.0
 isort==4.3.21

tooling/src/hypothesistooling/projects/hypothesispython.py

@@ -201,11 +201,11 @@ def upload_distribution():
     # https://developer.github.com/v3/repos/releases/#create-a-release
     requests.post(
         "https://api.github.com/repos/HypothesisWorks/hypothesis/releases",
-        json=dict(
-            tag_name=tag_name(),
-            name="Hypothesis for Python - version " + current_version(),
-            body=changelog_body,
-        ),
+        json={
+            "tag_name": tag_name(),
+            "name": "Hypothesis for Python - version " + current_version(),
+            "body": changelog_body,
+        },
         timeout=120,  # seconds
         # Scoped personal access token, stored in Travis environ variable
         auth=("Zac-HD", os.environ["Zac_release_token"]),