revert more matters of taste

Liam-DeVoe · Liam-DeVoe · commit 26fee6a74d08 · 2026-02-11T09:56:48.000+07:00
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 this
+shrink early, but by making the shrinker better we try to ensure that that
 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/hypothesis-python/docs/changelog.rst b/hypothesis-python/docs/changelog.rst
@@ -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 seriously wrong. No new features will be added, no breaking API changes
+something goes really really 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.
 
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 extremely annoying to write automated tests for, so I've
+    # This would be really really 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/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 at
+        """Called after a key has been evicted, with the score it had 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 comes first.
+            # only one option is possible, so whatever it is is first.
             return 0
         return int(choice)
     elif isinstance(choice, bytes):
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 this matters."""
+    called enough times that that matters."""
     return (n + 7) >> 3
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]
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 extremely large integers, use hex because power-of-two bases are cheaper
+        # for very very 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 this is just an
+    # list in sorted order anyway if it had to, and that that 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.
-    # | <y1 y2>  The bit at position n is set if n falls inside that interval.
+    # | <yy yy>  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 list", "Test functions for idempotence one at a time."),
+        ("--idempotent sorted sorted", "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 extremely occasionally - rarely enough to not be worth
+# This health check fails very very occasionally - rarely enough to not be worth
 # investigation
 @settings(max_examples=100, suppress_health_check=[HealthCheck.filter_too_much])
 @given(ConstantLists)
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-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-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 the strategy produced to get a new strategy.
+the values that that 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 this wasn't it at all. The error could be arbitrarily large,
+investigation it turned out that that 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 Hypothesis 3.38.4.
+A small change, but a very helpful one! This came in in Hypothesis 3.38.4.
 
 ### Health check overhaul
 

Original file line number	Diff line number	Diff line change
`@@ -1144,7 +1144,7 @@ def try_shrinking_nodes(self, nodes, n):`
`1144`	`1144`	`# case of this function of preserving from the right instead of`
`1145`	`1145`	`# preserving from the left. see test_can_shrink_variable_string_draws.`
`1146`	`1146`
`1147`		`- index, attempt_choice_type, attempt_constraints, _attempt_forced = (`
	`1147`	`+ (index, attempt_choice_type, attempt_constraints, _attempt_forced) = (`
`1148`	`1148`	`attempt.misaligned_at`
`1149`	`1149`	`)`
`1150`	`1150`	`node = self.nodes[index]`