Defer exit in lint() and fix all duplicate-word cases

veeceey · claude · veeceey · commit 6ef9519571dc · 2026-02-08T18:02:20.000-08:00
Restructure the duplicate-word check in lint() to set a failure flag
instead of calling sys.exit(1) immediately, so all checks run before
exiting. Fix all existing duplicate-word cases across the codebase by
deduplicating or rephrasing as appropriate. Also require 2+ letter
words in the duplicate-word pattern to avoid false positives from
single-letter matches in escape sequences.

Co-Authored-By: Claude Opus 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/guides/api-style.rst b/guides/api-style.rst
@@ -149,7 +149,7 @@ The main reasons for preferring this style are:
 * Errors at test import time tend to throw people and be correspondingly hard
   for them to debug.
   There's an expectation that errors in your test code result in failures in
-  your tests, and the fact that that test code happens to be defined in a
+  your tests, and the fact that the test code happens to be defined in a
   decorator doesn't seem to change that expectation for people.
 * Things like deprecation warnings etc. localize better when they happen
   inside the test - test runners will often swallow them or put them in silly
diff --git a/guides/internals.rst b/guides/internals.rst
@@ -240,7 +240,7 @@ but is now just noise.
 
 Because the shrinker runs in a big loop, if we've made progress the shrink pass
 will always be run again (assuming we don't hit some limit that terminates the
-shrink early, but by making the shrinker better we try to ensure that that
+shrink early, but by making the shrinker better we try to ensure that this
 never happens).
 This means that we will always get an opportunity to start again later if we
 made progress, and if we didn't make progress we've tried everything anyway.
diff --git a/guides/testing-hypothesis.rst b/guides/testing-hypothesis.rst
@@ -6,7 +6,7 @@ Note: This guide is currently entirely specific to the Python version of
 Hypothesis.
 
 This is a guide to the process of testing Hypothesis itself, both how to
-run its tests and how to to write new ones.
+run its tests and how to write new ones.
 
 --------------------------
 General Testing Philosophy
diff --git a/hypothesis-python/docs/changelog.rst b/hypothesis-python/docs/changelog.rst
@@ -8272,7 +8272,7 @@ caused an internal error.  This bug was introduced in :ref:`version 5.8.1 <v5.8.
 5.10.1 - 2020-04-19
 -------------------
 
-This release is a small internal refactoring to how shrinking interacts with :ref:`targeted property-based testing <targeted>` that should have no user user visible impact.
+This release is a small internal refactoring to how shrinking interacts with :ref:`targeted property-based testing <targeted>` that should have no user visible impact.
 
 .. _v5.10.0:
 
@@ -8773,7 +8773,7 @@ Removals
 - ``hypothesis.settings.buffer``, without replacement
 - ``hypothesis.PrintSettings``, because :obj:`hypothesis.settings.print_blob` takes ``True`` or ``False``
 - ``hypothesis.settings.timeout``, in favor of :obj:`hypothesis.settings.deadline`
-- ``hypothesis.unlimited`` without replacement (only only useful as argument to ``timeout``)
+- ``hypothesis.unlimited`` without replacement (only useful as argument to ``timeout``)
 
 Hypothesis 4.x
 ==============
@@ -14193,7 +14193,7 @@ Hypothesis now emits deprecation warnings if you apply
 :func:`@given <hypothesis.given>` more than once to a target.
 
 Applying :func:`@given <hypothesis.given>` repeatedly wraps the target multiple
-times. Each wrapper will search the space of of possible parameters separately.
+times. Each wrapper will search the space of possible parameters separately.
 This is equivalent but will be much more inefficient than doing it with a
 single call to :func:`@given <hypothesis.given>`.
 
@@ -15659,7 +15659,7 @@ Minor bug fix release.
   can both now be called with an empty argument
   list, in which case they also never generate any values.
 * :func:`~hypothesis.strategies.one_of` may now be called with a single argument that is a collection of strategies
-  as well as as varargs.
+  as well as varargs.
 * Add a :func:`~hypothesis.strategies.runner` strategy which returns the instance of the current test object
   if there is one.
 * 'Bundle' for RuleBasedStateMachine is now a normal(ish) strategy and can be used
@@ -16807,7 +16807,7 @@ This release could also be called 1.0-RC1.
 
 It contains a teeny tiny bugfix, but the real point of this release is to declare
 feature freeze. There will be zero functionality changes between 0.9.0 and 1.0 unless
-something goes really really wrong. No new features will be added, no breaking API changes
+something goes seriously wrong. No new features will be added, no breaking API changes
 will occur, etc. This is the final shakedown before I declare Hypothesis stable and ready
 to use and throw a party to celebrate.
 
@@ -17026,7 +17026,7 @@ Bug fixes:
 
 Other:
 
-* A lot of internals have been been rewritten. This shouldn't affect you at all, but
+* A lot of internals have been rewritten. This shouldn't affect you at all, but
   it opens the way for certain of hypothesis's oddities to be a lot more extensible by
   users. Whether this is a good thing may be up for debate...
 
diff --git a/hypothesis-python/src/_hypothesis_ftz_detector.py b/hypothesis-python/src/_hypothesis_ftz_detector.py
@@ -147,7 +147,7 @@ def key(name: str) -> tuple[bool, int, str]:
 
 
 if __name__ == "__main__":
-    # This would be really really annoying to write automated tests for, so I've
+    # This would be extremely annoying to write automated tests for, so I've
     # done some manual exploratory testing: `pip install grequests gevent==21.12.0`,
     # and call print() as desired to observe behavior.
     import grequests  # noqa
diff --git a/hypothesis-python/src/hypothesis/database.py b/hypothesis-python/src/hypothesis/database.py
@@ -1027,7 +1027,7 @@ def _get_bytes(self, url: str) -> bytes | None:  # pragma: no cover
             else:
                 warning_message = (
                     "Could not get the latest artifact from GitHub. "
-                    "This could be because because the repository "
+                    "This could be because the repository "
                     "or artifact does not exist. "
                 )
             # see https://github.com/python/cpython/issues/128734
diff --git a/hypothesis-python/src/hypothesis/extra/_array_helpers.py b/hypothesis-python/src/hypothesis/extra/_array_helpers.py
@@ -607,7 +607,7 @@ def _draw_loop_dimensions(self, data, use=None):
                 else:
                     side = dim_side
 
-                # Use a trick where where a biased coin is queried to see
+                # Use a trick where a biased coin is queried to see
                 # if the given shape-tuple will continue to be grown. All
                 # of the relevant draws will still be made for the given
                 # shape-tuple even if it is no longer being added to.
diff --git a/hypothesis-python/src/hypothesis/extra/array_api.py b/hypothesis-python/src/hypothesis/extra/array_api.py
@@ -784,7 +784,7 @@ def indices(
       :func:`~hypothesis.strategies.slices` instead.
     * ``min_dims`` is the minimum dimensionality of the resulting array from use
       of the generated index.
-    * ``max_dims`` is the the maximum dimensionality of the resulting array,
+    * ``max_dims`` is the maximum dimensionality of the resulting array,
       defaulting to ``len(shape) if not allow_newaxis else
       max(len(shape), min_dims) + 2``.
     * ``allow_ellipsis`` specifies whether ``None`` is allowed in the index.
diff --git a/hypothesis-python/src/hypothesis/extra/numpy.py b/hypothesis-python/src/hypothesis/extra/numpy.py
@@ -1166,7 +1166,7 @@ def basic_indices(
     * ``min_dims`` is the minimum dimensionality of the resulting array from use
       of the generated index. When ``min_dims == 0``, scalars and zero-dimensional
       arrays are both allowed.
-    * ``max_dims`` is the the maximum dimensionality of the resulting array,
+    * ``max_dims`` is the maximum dimensionality of the resulting array,
       defaulting to ``len(shape) if not allow_newaxis else
       max(len(shape), min_dims) + 2``.
     * ``allow_newaxis`` specifies whether ``None`` is allowed in the index.
diff --git a/hypothesis-python/src/hypothesis/internal/cache.py b/hypothesis-python/src/hypothesis/internal/cache.py
@@ -193,7 +193,7 @@ def on_access(self, key: K, value: V, score: Any) -> Any:
         return score
 
     def on_evict(self, key: K, value: V, score: Any) -> Any:
-        """Called after a key has been evicted, with the score it had had at
+        """Called after a key has been evicted, with the score it had at
         the point of eviction."""
 
     def check_valid(self) -> None:
diff --git a/hypothesis-python/src/hypothesis/internal/conjecture/choice.py b/hypothesis-python/src/hypothesis/internal/conjecture/choice.py
@@ -395,7 +395,7 @@ def choice_to_index(choice: ChoiceT, constraints: ChoiceConstraintsT) -> int:
         # Ordered by [False, True].
         p = constraints["p"]
         if not (2 ** (-64) < p < (1 - 2 ** (-64))):
-            # only one option is possible, so whatever it is is first.
+            # only one option is possible, so whatever it is comes first.
             return 0
         return int(choice)
     elif isinstance(choice, bytes):
diff --git a/hypothesis-python/src/hypothesis/internal/conjecture/data.py b/hypothesis-python/src/hypothesis/internal/conjecture/data.py
@@ -142,7 +142,7 @@ def structural_coverage(label: int) -> StructuralCoverageTag:
 class Span:
     """A span tracks the hierarchical structure of choices within a single test run.
 
-    Spans are created to mark regions of the choice sequence that that are
+    Spans are created to mark regions of the choice sequence that are
     logically related to each other. For instance, Hypothesis tracks:
     - A single top-level span for the entire choice sequence
     - A span for the choices made by each strategy
diff --git a/hypothesis-python/src/hypothesis/internal/conjecture/junkdrawer.py b/hypothesis-python/src/hypothesis/internal/conjecture/junkdrawer.py
@@ -559,5 +559,5 @@ def endswith(l1: Sequence[T], l2: Sequence[T]) -> bool:
 def bits_to_bytes(n: int) -> int:
     """The number of bytes required to represent an n-bit number.
     Equivalent to (n + 7) // 8, but slightly faster. This really is
-    called enough times that that matters."""
+    called enough times that this matters."""
     return (n + 7) >> 3
diff --git a/hypothesis-python/src/hypothesis/strategies/_internal/attrs.py b/hypothesis-python/src/hypothesis/strategies/_internal/attrs.py
@@ -164,7 +164,7 @@ def types_to_strategy(attrib: Attribute, types: Collection[Any]) -> SearchStrate
         return st.from_type(typ)
     elif types:
         # We have a list of tuples of types, and want to find a type
-        # (or tuple of types) that is a subclass of all of of them.
+        # (or tuple of types) that is a subclass of all of them.
         type_tuples = [k if isinstance(k, tuple) else (k,) for k in types]
         # Flatten the list, filter types that would fail validation, and
         # sort so that ordering is stable between runs and shrinks well.
diff --git a/hypothesis-python/src/hypothesis/strategies/_internal/core.py b/hypothesis-python/src/hypothesis/strategies/_internal/core.py
@@ -1518,7 +1518,7 @@ def _get_typeddict_qualifiers(key, annotation_type):
 
     # If there's no explicitly registered strategy, maybe a subtype of thing
     # is registered - if so, we can resolve it to the subclass strategy.
-    # We'll start by checking if thing is from from the typing module,
+    # We'll start by checking if thing is from the typing module,
     # because there are several special cases that don't play well with
     # subclass and instance checks.
     if (
diff --git a/hypothesis-python/src/hypothesis/vendor/pretty.py b/hypothesis-python/src/hypothesis/vendor/pretty.py
@@ -919,7 +919,7 @@ def _repr_integer(obj: int, p: RepresentationPrinter, cycle: bool) -> None:
         # add underscores for integers over ten decimal digits
         p.text(f"{obj:#_d}")
     else:
-        # for very very large integers, use hex because power-of-two bases are cheaper
+        # for extremely large integers, use hex because power-of-two bases are cheaper
         # https://docs.python.org/3/library/stdtypes.html#integer-string-conversion-length-limitation
         p.text(f"{obj:#_x}")
 
diff --git a/hypothesis-python/tests/conjecture/test_order_shrinking.py b/hypothesis-python/tests/conjecture/test_order_shrinking.py
@@ -19,7 +19,7 @@
 def test_shrinks_down_to_sorted_the_slow_way(ls):
     # We normally would short-circuit and find that we can sort this
     # automatically, but here we test that a single run_step could put the
-    # list in sorted order anyway if it had to, and that that is just an
+    # list in sorted order anyway if it had to, and that this is just an
     # optimisation.
     shrinker = Ordering(ls, lambda ls: True, full=False)
     shrinker.run_step()
diff --git a/hypothesis-python/tests/cover/test_charmap.py b/hypothesis-python/tests/cover/test_charmap.py
@@ -139,7 +139,7 @@ def test_union_empty():
 
 def test_union_handles_totally_overlapped_gap():
     #   < xx  >  Imagine the intervals x and y as bit strings.
-    # | <yy yy>  The bit at position n is set if n falls inside that interval.
+    # | <y1 y2>  The bit at position n is set if n falls inside that interval.
     # = <zzzzz>  In this model _union_intervals() performs bit-wise or.
     assert _union_intervals([[2, 3]], [[1, 2], [4, 5]]) == ((1, 5),)
 
diff --git a/hypothesis-python/tests/ghostwriter/test_ghostwriter_cli.py b/hypothesis-python/tests/ghostwriter/test_ghostwriter_cli.py
@@ -85,7 +85,7 @@ def test_cli_python_equivalence(cli, code):
 @pytest.mark.parametrize(
     "cli,err_msg",
     [
-        ("--idempotent sorted sorted", "Test functions for idempotence one at a time."),
+        ("--idempotent sorted list", "Test functions for idempotence one at a time."),
         (
             "xxxx",
             "Found the 'builtins' module, but it doesn't have a 'xxxx' attribute.",
diff --git a/hypothesis-python/tests/nocover/test_flatmap.py b/hypothesis-python/tests/nocover/test_flatmap.py
@@ -33,7 +33,7 @@
 OrderedPairs = integers(1, 200).flatmap(lambda e: tuples(integers(0, e - 1), just(e)))
 
 
-# This health check fails very very occasionally - rarely enough to not be worth
+# This health check fails extremely occasionally - rarely enough to not be worth
 # investigation
 @settings(max_examples=100, suppress_health_check=[HealthCheck.filter_too_much])
 @given(ConstantLists)
diff --git a/tooling/src/hypothesistooling/__main__.py b/tooling/src/hypothesistooling/__main__.py
@@ -80,6 +80,10 @@ def lint():
     pip_tool("ruff", "check", ".")
     codespell(*(p for p in tools.all_files() if not p.name.endswith("by-domain.txt")))
 
+    from textwrap import indent
+
+    failed = False
+
     matches = subprocess.run(
         r"git grep -En '@(dataclasses\.)?dataclass\(.*\)' "
         "| grep -Ev 'frozen=.*slots=|slots=.*frozen='",
@@ -88,24 +92,23 @@ def lint():
         text=True,
     ).stdout
     if matches:
-        from textwrap import indent
-
         print("\nAll dataclass decorators must pass slots= and frozen= arguments:")
         print(indent(matches, "    "))
-        sys.exit(1)
+        failed = True
 
     dupes = subprocess.run(
-        r"git grep -nP '\b([a-z]+)\s+\1\b'"
+        r"git grep -nP '\b([a-z]{2,})\s+\1\b'"
         " -- ':!*.svg' ':!*.png' ':!*.jpg' ':!*.sketch'",
         shell=True,
         capture_output=True,
         text=True,
     ).stdout
     if dupes:
-        from textwrap import indent
-
         print("\nDuplicate word(s) found:")
         print(indent(dupes, "    "))
+        failed = True
+
+    if failed:
         sys.exit(1)
 
 
diff --git a/website/content/2016-04-15-economics-of-software-correctness.md b/website/content/2016-04-15-economics-of-software-correctness.md
@@ -9,7 +9,7 @@ You have probably never written a significant piece of correct software.
 
 That's not a value judgement. It's certainly not a criticism of your competence. I can say with almost complete confidence that every non-trivial piece of software I have written contains at least one bug. You *might* have written small libraries that are essentially bug free, but the chance that you have written a non-trivial bug free program is tantamount to zero.
 
-I don't even mean this in some pedantic academic sense. I'm talking about behaviour where if someone spotted it and pointed it out to you you would probably admit that it's a bug. It might even be a bug that you cared about.
+I don't even mean this in some pedantic academic sense. I'm talking about behaviour where if someone spotted it and pointed it out to you, you would probably admit that it's a bug. It might even be a bug that you cared about.
 
 Why is this?
 
diff --git a/website/content/2016-04-16-quickcheck-in-every-language.md b/website/content/2016-04-16-quickcheck-in-every-language.md
@@ -33,7 +33,7 @@ I thought it would be worth keeping track of which are which, so I've put togeth
 	<li>Must be under an OSI approved license.</li>
 </ol>
 <p>
-In this I've tried to to collect a list of what I think the best ones are for any given language.
+In this I've tried to collect a list of what I think the best ones are for any given language.
 I haven't used all of these, but I've used some and read and talked to people about the others.
 </p>
 
@@ -198,7 +198,7 @@ I haven't put in the depth of in time to be sure, not that I have doubts.</p>
 </p>
 
 <p>
-  For the rest though? I'm glad they exist! I care about testing about about high quality software,
+  For the rest though? I'm glad they exist! I care about testing and about high quality software,
   and they're doing their part to make it possible.
 </p>
 
diff --git a/website/content/2016-05-29-testing-optimizers-with-hypothesis.md b/website/content/2016-05-29-testing-optimizers-with-hypothesis.md
@@ -142,7 +142,7 @@ Draw 1: (1, 1)
 
 In this case what happens is the opposite: Previously the greedy
 algorithm was reaching for the (1, 1) item as the most appealing because
-it had the highest value to weight ratio, but by including it it only
+it had the highest value to weight ratio, but by including it, it only
 had space for one of the remaining two. When Hypothesis removed that
 option, it could fit the remaining two items into its knapsack and thus
 scored a higher point.
diff --git a/website/content/2016-06-13-testing-configuration-parameters.md b/website/content/2016-06-13-testing-configuration-parameters.md
@@ -27,7 +27,7 @@ application.
 
 This means that they are relatively easy to test with property-based
 testing. You take an existing test - either one that is already using
-Hypothesis or a normal example based test test - and you vary some
+Hypothesis or a normal example based test - and you vary some
 configuration parameters and make sure the test still passes.
 
 This turns out to be remarkably effective. Here's an example where I
diff --git a/website/content/2016-06-30-tests-as-complete-specifications.md b/website/content/2016-06-30-tests-as-complete-specifications.md
@@ -110,7 +110,7 @@ Falsifying example: test_inserting_at_smaller_index_gives_unsorted(
 
 (you may also get (ls=[-1, 0, 0, 0, 0], v=0))
 
-However when I run it it usually *doesn't* fail the first time. It
+However when I run it, it usually *doesn't* fail the first time. It
 usually takes somewhere between two and five runs before it fails. This
 is because in order to trigger this behaviour being wrong you need
 quite specific behaviour: value needs to appear in ls at least
diff --git a/website/content/2016-12-08-compositional-shrinking.md b/website/content/2016-12-08-compositional-shrinking.md
@@ -51,7 +51,7 @@ def test_even_numbers_are_even(n):
 ```
 
 We took a strategy and composed it with a function mapping over
-the values that that strategy produced to get a new strategy.
+the values that the strategy produced to get a new strategy.
 
 Suppose the Hypothesis strategy implementation looked something
 like the following:
diff --git a/website/content/2017-09-28-threshold-problem.md b/website/content/2017-09-28-threshold-problem.md
@@ -25,7 +25,7 @@ dig up the IRC logs, but the exact number doesn't matter).
 Hypothesis said "Ah ha! Here is an example where the error is 0.500001. A bug!".
 
 Ned sighed and thought "Oh great, floating point precision issues", but on further
-investigation it turned out that that wasn't it at all. The error could be arbitrarily large,
+investigation it turned out that this wasn't it at all. The error could be arbitrarily large,
 it's just that Hypothesis reliably gave an example where it was almost as small as it could
 possibly be and still fail.
 
diff --git a/website/content/2018-01-08-smarkets.md b/website/content/2018-01-08-smarkets.md
@@ -82,7 +82,7 @@ you'll now see a line like the following:
 - Fraction of time spent in data generation: ~ 12%
 ```
 
-A small change, but a very helpful one! This came in in Hypothesis 3.38.4.
+A small change, but a very helpful one! This came in Hypothesis 3.38.4.
 
 ### Health check overhaul
 
diff --git a/website/content/2020-06-08-complex-data-strategies.md b/website/content/2020-06-08-complex-data-strategies.md
@@ -10,7 +10,7 @@ Once you learn the basics, there are two hard parts to using property-based test
 * What are good properties to test?
 * How do I generate complex inputs?
 
-These are also the the _main_ parts of property-based testing! And both require some skill and creativity to solve. This post is to help you get some basics on the second question, how we generate complex inputs. Often we're working with data that has lots of preconditions and we want to actually generate inputs that satisfies the preconditions. We also often need to create data that depends on other data, or data with extra conditions, or [independent-but-similar](https://www.hillelwayne.com/post/metamorphic-testing/) data. We need some way to build more complex strategies.
+These are also the _main_ parts of property-based testing! And both require some skill and creativity to solve. This post is to help you get some basics on the second question, how we generate complex inputs. Often we're working with data that has lots of preconditions and we want to actually generate inputs that satisfies the preconditions. We also often need to create data that depends on other data, or data with extra conditions, or [independent-but-similar](https://www.hillelwayne.com/post/metamorphic-testing/) data. We need some way to build more complex strategies.
 
 There are a few different ways to do this, so let's go into each of them.
 

Original file line number	Diff line number	Diff line change
`@@ -1027,7 +1027,7 @@ def _get_bytes(self, url: str) -> bytes \| None: # pragma: no cover`
`1027`	`1027`	`else:`
`1028`	`1028`	`warning_message = (`
`1029`	`1029`	`"Could not get the latest artifact from GitHub. "`
`1030`		`- "This could be because because the repository "`
	`1030`	`+ "This could be because the repository "`
`1031`	`1031`	`"or artifact does not exist. "`
`1032`	`1032`	`)`
`1033`	`1033`	`# see https://github.com/python/cpython/issues/128734`