Merge pull request #4658 from veeceey/fix/typo-combined-fixes

Liam-DeVoe · web-flow · commit 2822e661b8e9 · 2026-02-10T23:13:47.000-05:00
Fix duplicate word typos in comments and documentation
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/RELEASE.rst b/hypothesis-python/RELEASE.rst
@@ -0,0 +1,3 @@
+RELEASE_TYPE: patch
+
+This patch fixes several duplicate word typos in comments and documentation.
diff --git a/hypothesis-python/docs/changelog.rst b/hypothesis-python/docs/changelog.rst
@@ -6264,7 +6264,7 @@ affecting the :pypi:`returns` package (:issue:`3060`).
 6.14.8 - 2021-08-16
 -------------------
 
-This patch ensures that registering a strategy for a subclass of a a parametrised
+This patch ensures that registering a strategy for a subclass of a parametrised
 generic type such as ``class Lines(Sequence[str]):`` will not "leak" into unrelated
 strategies such as ``st.from_type(Sequence[int])`` (:issue:`2951`).
 Unfortunately this fix requires :pep:`560`, meaning Python 3.7 or later.
@@ -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
 ==============
@@ -8806,7 +8806,7 @@ with :func:`~hypothesis.strategies.from_type`:
 - :class:`python:typing.SupportsRound`
 
 Note that using :func:`~hypothesis.strategies.from_type` with one of the above strategies will not
-ensure that the the specified function will execute successfully (ie : the strategy returned for
+ensure that the specified function will execute successfully (ie : the strategy returned for
 ``from_type(typing.SupportsAbs)`` may include NaNs or things which cause the :func:`python:abs`
 function to error. )
 
@@ -12837,7 +12837,7 @@ not recommended for direct use by other users of Hypothesis.
 -------------------
 
 This release adds a new mechanism to infer strategies for classes
-defined using :pypi:`attrs`, based on the the type, converter, or
+defined using :pypi:`attrs`, based on the type, converter, or
 validator of each attribute.  This inference is now built in to
 :func:`~hypothesis.strategies.builds` and :func:`~hypothesis.strategies.from_type`.
 
@@ -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
@@ -16186,7 +16186,7 @@ Bug fixes:
 1.11.0 - 2015-08-31
 -------------------
 
-* text() with a non-string alphabet would have used the repr() of the the alphabet
+* text() with a non-string alphabet would have used the repr() of the alphabet
   instead of its contexts. This is obviously silly. It now works with any sequence
   of things convertible to unicode strings.
 * @given will now work on methods whose definitions contains no explicit positional
@@ -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/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
@@ -1105,7 +1105,7 @@ def fetch(self, key: bytes) -> Iterable[bytes]:
         kp = self._key_path(key)
 
         with ZipFile(self._artifact) as zf:
-            # Get the all files in the the kp from the cache
+            # Get all the files in the kp from the cache
             filenames = self._access_cache.get(kp, ())
             for filename in filenames:
                 with zf.open(filename.as_posix()) as f:
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/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/shrinker.py b/hypothesis-python/src/hypothesis/internal/conjecture/shrinker.py
@@ -1144,7 +1144,7 @@ def try_shrinking_nodes(self, nodes, n):
             # case of this function of preserving from the right instead of
             # preserving from the left. see test_can_shrink_variable_string_draws.
 
-            (index, attempt_choice_type, attempt_constraints, _attempt_forced) = (
+            index, attempt_choice_type, attempt_constraints, _attempt_forced = (
                 attempt.misaligned_at
             )
             node = self.nodes[index]
@@ -1291,7 +1291,7 @@ def _node_program(self, chooser, program):
 
         # Because we run in a random order we will often find ourselves in the middle
         # of a region where we could run the node program. We thus start by moving
-        # left to the beginning of that region if possible in order to to start from
+        # left to the beginning of that region if possible in order to start from
         # the beginning of that region.
         def offset_left(k):
             return i - k * n
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/tests/conjecture/test_choice.py b/hypothesis-python/tests/conjecture/test_choice.py
@@ -69,7 +69,7 @@
 @example(("integer", integer_constr(-(2**200), 2**200)))
 @given(choice_types_constraints())
 def test_compute_max_children_is_positive(choice_type_and_constraints):
-    (choice_type, constraints) = choice_type_and_constraints
+    choice_type, constraints = choice_type_and_constraints
     assert compute_max_children(choice_type, constraints) >= 0
 
 
@@ -206,7 +206,7 @@ def test_draw_string_single_interval_with_equal_bounds(s, n):
 @given(choice_types_constraints())
 @settings(suppress_health_check=[HealthCheck.filter_too_much])
 def test_compute_max_children_and_all_children_agree(choice_type_and_constraints):
-    (choice_type, constraints) = choice_type_and_constraints
+    choice_type, constraints = choice_type_and_constraints
     max_children = compute_max_children(choice_type, constraints)
 
     # avoid slowdowns / OOM when reifying extremely large all_children generators.
@@ -390,7 +390,7 @@ def test_data_with_same_forced_value_is_valid(node):
 @given(choice_types_constraints())
 @settings(suppress_health_check=[HealthCheck.filter_too_much])
 def test_all_children_are_permitted_values(choice_type_and_constraints):
-    (choice_type, constraints) = choice_type_and_constraints
+    choice_type, constraints = choice_type_and_constraints
     max_children = compute_max_children(choice_type, constraints)
 
     cap = min(100_000, MAX_CHILDREN_EFFECTIVELY_INFINITE)
@@ -769,7 +769,7 @@ def test_node_template_simplest_is_actually_trivial(node):
 @example(("boolean", {"p": 0}))
 @example(("boolean", {"p": 1}))
 def test_choice_indices_are_positive(choice_type_and_constraints):
-    (choice_type, constraints) = choice_type_and_constraints
+    choice_type, constraints = choice_type_and_constraints
     v = draw_value(choice_type, constraints)
     assert choice_to_index(v, constraints) >= 0
 
@@ -786,7 +786,7 @@ def test_shrink_towards_has_index_0(constraints):
 @settings(max_examples=20)
 def test_choice_to_index_injective(choice_type_and_constraints):
     # choice sequence ordering should be injective both ways.
-    (choice_type, constraints) = choice_type_and_constraints
+    choice_type, constraints = choice_type_and_constraints
     # ...except for floats, which are hard to order bijectively.
     assume(choice_type != "float")
     # cap to 10k so this test finishes in a reasonable amount of time
@@ -810,7 +810,7 @@ def test_choice_to_index_injective(choice_type_and_constraints):
     )
 )
 def test_choice_from_value_injective(choice_type_and_constraints):
-    (choice_type, constraints) = choice_type_and_constraints
+    choice_type, constraints = choice_type_and_constraints
     assume(choice_type != "float")
     cap = min(compute_max_children(choice_type, constraints), 10_000)
 
@@ -823,7 +823,7 @@ def test_choice_from_value_injective(choice_type_and_constraints):
 
 @given(choice_types_constraints())
 def test_choice_index_and_value_are_inverses(choice_type_and_constraints):
-    (choice_type, constraints) = choice_type_and_constraints
+    choice_type, constraints = choice_type_and_constraints
     v = draw_value(choice_type, constraints)
     index = choice_to_index(v, constraints)
     note({"v": v, "index": index})
diff --git a/tooling/src/hypothesistooling/__main__.py b/tooling/src/hypothesistooling/__main__.py
@@ -15,6 +15,7 @@
 import sys
 from datetime import date
 from pathlib import Path
+from textwrap import indent
 
 import requests
 from coverage.config import CoverageConfig
@@ -80,6 +81,8 @@ def lint():
     pip_tool("ruff", "check", ".")
     codespell(*(p for p in tools.all_files() if not p.name.endswith("by-domain.txt")))
 
+    failed = False
+
     matches = subprocess.run(
         r"git grep -En '@(dataclasses\.)?dataclass\(.*\)' "
         "| grep -Ev 'frozen=.*slots=|slots=.*frozen='",
@@ -88,10 +91,22 @@ def lint():
         text=True,
     ).stdout
     if matches:
-        from textwrap import indent
-
         print("\nAll dataclass decorators must pass slots= and frozen= arguments:")
         print(indent(matches, "    "))
+        failed = True
+
+    matches = subprocess.run(
+        r"git grep -nP '\b(the|as|a|to|because|user|test|about|from|only)\s+\1\b'",
+        shell=True,
+        capture_output=True,
+        text=True,
+    ).stdout
+    if matches:
+        print("\nFound duplicate words:")
+        print(indent(matches, "    "))
+        failed = True
+
+    if failed:
         sys.exit(1)
 
 
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-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/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
`@@ -0,0 +1,3 @@`
	`1`	`+RELEASE_TYPE: patch`
	`2`	`+`
	`3`	`+This patch fixes several duplicate word typos in comments and documentation.`