assertpy2 2.23.0__tar.gz → 2.24.0__tar.gz

{assertpy2-2.23.0 → assertpy2-2.24.0}/CONTRIBUTING.md

@@ -23,17 +23,26 @@ Read more about how pulls work on GitHub's [About pull requests](https://help.gi
 - Python 3.10+
 - [uv](https://docs.astral.sh/uv/) as the package manager
 
+## Before you change a public signature
+
+Read [ARCHITECTURE.md](ARCHITECTURE.md). Four files under `assertpy2/_engine/` are generated, the public
+surface is pinned by a recorded snapshot, and neither is discoverable from the files themselves.
+
 ## Verification pipeline
 
 Run all checks before submitting a PR. Every step must pass.
 
-Install exactly this set. A bare `uv sync` leaves out the optional libraries several tests import, and
-those tests fail rather than skip:
+### Install
+
+A bare `uv sync` leaves out the optional libraries several tests import, and those tests then fail
+rather than skip. Install exactly this set:
 
 ```bash
 uv sync --extra json --extra data --extra inline --group integrations --group docs-examples
 ```
 
+### The main gate
+
 ```bash
 uv run ruff check .
 uv run ruff format --check .
@@ -43,22 +52,58 @@ uv run pytest tests/test_docs_examples.py tests/test_typing_claims.py
 uv run --group docs mkdocs build --strict
 ```
 
-The public typing surface is checked by three checkers. Run them after the block above, not before:
-`uv run --group typecheck` adds the checkers to the same `.venv` and leaves them there, and a coverage
-run with them installed collects a different set:
+CI requires 100% code coverage.
+
+### Then once on the supported floor
+
+Run the suite on Python 3.10 as well. This is not optional, and the block above does not cover it.
+
+A union carries `__name__` from 3.14 onwards and not before. `logging.LoggerAdapter` became
+subscriptable in 3.11. Neither difference is visible to a type checker told to target 3.10, and both
+shipped as defects that every other gate passed.
+
+Use a throwaway environment. `uv run --python 3.10` inside the project rebuilds `.venv` for that
+version, and on Windows it can fail partway and leave you without pytest:
+
+```bash
+uv venv /tmp/py310 --python 3.10
+
+export VIRTUAL_ENV=/tmp/py310
+uv pip install -e ".[json,data,inline]"
+uv pip install pytest pytest-cov hypothesis ruff
+uv pip install attrs pydantic requests httpx flask
+
+/tmp/py310/bin/python -m pytest tests --ignore=tests/test_docs_examples.py -q
+```
+
+`ruff` belongs in that list: the tests that compare a generated file against its generator shell out
+to it, and without it they fail for a reason that has nothing to do with your change.
+
+### The four type checkers
+
+Run these after the main gate, not before. `uv run --group typecheck` adds the checkers to the same
+`.venv` and leaves them there, and a coverage run with them installed collects a different set:
 
 ```bash
 uv run --group typecheck mypy --strict --follow-imports=silent tests/test_typing.py
-uv run --group typecheck pyright --pythonversion 3.14 tests/test_typing.py
+PYRIGHT_PYTHON_FORCE_VERSION=1.1.413 uv run --group typecheck pyright --pythonversion 3.14 tests/test_typing.py
+uv run --group typecheck pyrefly check tests/test_typing.py
 uv run --group typecheck pytest tests/test_pyright_baseline.py
 ```
 
-`--pythonversion 3.14` is not decoration. Pyright reports against the interpreter it finds unless told
-otherwise, and the count moves with it: 108 diagnostics for this package on 3.10 against 102 on 3.14.
+`PYRIGHT_PYTHON_FORCE_VERSION` picks the engine rather than the launcher. The `pyright` distribution on
+PyPI stopped at 1.1.411 on 25 June while npm has shipped 1.1.412 and 1.1.413 since, so the launcher and
+the engine move apart. The baseline is recorded against one engine, and `tests/typing_harness.py` pins
+the same build, so only this direct invocation needs the variable.
+
+`--pythonversion 3.14` is not decoration. Pyright reports against the interpreter it finds unless
+told otherwise, and the count moves with it: 174 diagnostics for this package on 3.10 against 169 on
+3.14.
+
 Without it a contributor on the supported floor meets a red baseline that says nothing about their
 change. The baseline test passes the same target itself, so it gives one answer everywhere.
 
-Three details that cost time if you meet them the hard way:
+### Three details that cost time if you meet them the hard way
 
 - `ty check` is scoped on purpose. Run over the whole tree it reports hundreds of diagnostics from
   `tests/`, which is full of deliberate negative typing cases: calls that must not type-check.
@@ -68,8 +113,6 @@ Three details that cost time if you meet them the hard way:
 - `tests/test_docs_examples.py` is run separately because it executes the snippets in `docs/`, which
   needs the `docs-examples` group and a different collection.
 
-CI requires 100% code coverage.
-
 ## Commit style
 
 Use [Conventional Commits](https://www.conventionalcommits.org/): `feat:`, `fix:`, `refactor:`, `test:`, `docs:`, `chore:`, etc.

{assertpy2-2.23.0 → assertpy2-2.24.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: assertpy2
-Version: 2.23.0
+Version: 2.24.0
 Summary: Fluent assertion library for Python with composable matchers, structural matching, and full type safety
 Project-URL: Homepage, https://github.com/Solganis/assertpy2
 Project-URL: Repository, https://github.com/Solganis/assertpy2
@@ -68,7 +68,7 @@ Description-Content-Type: text/markdown
   <a href="https://pypi.org/project/assertpy2/"><img src="https://img.shields.io/pypi/pyversions/assertpy2" alt="Python"></a>
   <a href="https://pepy.tech/projects/assertpy2"><img src="https://static.pepy.tech/badge/assertpy2/month" alt="Downloads"></a>
   <br>
-  <a href="https://solganis.github.io/assertpy2/concepts/type-safety/"><img src="https://img.shields.io/badge/type--checked-ty%20%7C%20mypy%20%7C%20pyright-2ea043" alt="public overloads type-checked by ty, mypy --strict, and pyright with zero suppressions"></a>
+  <a href="https://solganis.github.io/assertpy2/concepts/type-safety/"><img src="https://img.shields.io/badge/overloads-ty%20%7C%20mypy%20%7C%20pyright%20%7C%20pyrefly-2ea043" alt="every public overload checked by ty, mypy --strict, pyright and pyrefly with zero suppressions"></a>
   <a href="https://solganis.github.io/assertpy2/"><img src="https://img.shields.io/badge/docs-online-black" alt="Documentation"></a>
   <a href="https://scorecard.dev/viewer/?uri=github.com/Solganis/assertpy2"><img src="https://img.shields.io/ossf-scorecard/github.com/Solganis/assertpy2?label=OpenSSF%20Scorecard" alt="OpenSSF Scorecard"></a>
 </p>
@@ -201,7 +201,7 @@ There are [45 matchers](https://solganis.github.io/assertpy2/guides/matchers/),
 <h2 align="center"><a href="https://solganis.github.io/assertpy2/concepts/type-safety/">Type-aware autocomplete</a></h2>
 
 `assert_that()` uses `@overload` to return type-specific Protocols.<br>
-Your IDE shows only methods relevant to the value you're testing, not all 100+:
+Your IDE shows only methods relevant to the value you're testing, not the whole surface:
 
 - `assert_that("hello").` &rarr; string methods: `starts_with`, `matches`, `is_alpha`, ...
 - `assert_that(42).` &rarr; numeric methods: `is_positive`, `is_between`, `is_close_to`, ...
@@ -221,7 +221,7 @@ An assertion hands the value back, statically narrowed.
 <!-- docs-guard: skip -->
 ```python
 order = assert_that(repo.find(42)).is_not_none().is_instance_of(PaidOrder).value
-order.refund()  # statically PaidOrder - verified by ty, mypy, and pyright
+order.refund()  # statically PaidOrder - verified by ty, mypy, pyright and pyrefly
 ```
 
 For API tests,

{assertpy2-2.23.0 → assertpy2-2.24.0}/README.md

@@ -16,7 +16,7 @@
   <a href="https://pypi.org/project/assertpy2/"><img src="https://img.shields.io/pypi/pyversions/assertpy2" alt="Python"></a>
   <a href="https://pepy.tech/projects/assertpy2"><img src="https://static.pepy.tech/badge/assertpy2/month" alt="Downloads"></a>
   <br>
-  <a href="https://solganis.github.io/assertpy2/concepts/type-safety/"><img src="https://img.shields.io/badge/type--checked-ty%20%7C%20mypy%20%7C%20pyright-2ea043" alt="public overloads type-checked by ty, mypy --strict, and pyright with zero suppressions"></a>
+  <a href="https://solganis.github.io/assertpy2/concepts/type-safety/"><img src="https://img.shields.io/badge/overloads-ty%20%7C%20mypy%20%7C%20pyright%20%7C%20pyrefly-2ea043" alt="every public overload checked by ty, mypy --strict, pyright and pyrefly with zero suppressions"></a>
   <a href="https://solganis.github.io/assertpy2/"><img src="https://img.shields.io/badge/docs-online-black" alt="Documentation"></a>
   <a href="https://scorecard.dev/viewer/?uri=github.com/Solganis/assertpy2"><img src="https://img.shields.io/ossf-scorecard/github.com/Solganis/assertpy2?label=OpenSSF%20Scorecard" alt="OpenSSF Scorecard"></a>
 </p>
@@ -149,7 +149,7 @@ There are [45 matchers](https://solganis.github.io/assertpy2/guides/matchers/),
 <h2 align="center"><a href="https://solganis.github.io/assertpy2/concepts/type-safety/">Type-aware autocomplete</a></h2>
 
 `assert_that()` uses `@overload` to return type-specific Protocols.<br>
-Your IDE shows only methods relevant to the value you're testing, not all 100+:
+Your IDE shows only methods relevant to the value you're testing, not the whole surface:
 
 - `assert_that("hello").` &rarr; string methods: `starts_with`, `matches`, `is_alpha`, ...
 - `assert_that(42).` &rarr; numeric methods: `is_positive`, `is_between`, `is_close_to`, ...
@@ -169,7 +169,7 @@ An assertion hands the value back, statically narrowed.
 <!-- docs-guard: skip -->
 ```python
 order = assert_that(repo.find(42)).is_not_none().is_instance_of(PaidOrder).value
-order.refund()  # statically PaidOrder - verified by ty, mypy, and pyright
+order.refund()  # statically PaidOrder - verified by ty, mypy, pyright and pyrefly
 ```
 
 For API tests,

{assertpy2-2.23.0 → assertpy2-2.24.0}/assertpy2/_clustering.py

@@ -188,8 +188,7 @@ def stable_repr(value: object, _seen: frozenset[int] = frozenset()) -> str:
     try:
         if isinstance(value, (set, frozenset)):
             members = sorted(stable_repr(member, inner) for member in value)
-            # an empty one falls back to `repr`, since `{}` is a dict, so `set()` and the `frozenset()` it equals
-            # read apart
+            # an empty one falls back to `repr`: `{}` is a dict, so `set()` and the `frozenset()` it equals read apart
             return "{" + ", ".join(members) + "}" if value else _safe_repr(value)
         if isinstance(value, dict):
             pairs = (f"{stable_repr(key, inner)}: {stable_repr(item, inner)}" for key, item in value.items())
@@ -287,8 +286,7 @@ def is_well_formed(key: Signature) -> bool:
         )
     if key.steps:
         return False
-    # exactly one of the two: a pair of values only for the kinds whose fields hold them, or a `contains` payload
-    # would print the `None` standing for a missing item
+    # a pair of values only for the kinds whose fields hold them, or a `contains` payload prints a `None`
     if key.label:
         return not key.values
     return len(key.values) == 2 and key.where in _VALUES_ARE_VALUES
@@ -327,8 +325,7 @@ def clusters(
     """
     if total_failures <= 0:
         return []
-    # keyed on the node id: `pytest-rerunfailures` reports one test failing per retry, and counting attempts printed
-    # a cluster of six over two tests
+    # keyed on the node id: `pytest-rerunfailures` retries printed a cluster of six over two tests
     grouped: dict[Signature, dict[str, None]] = {}
     actuals: dict[Signature, dict[str, None]] = {}
     expecteds: dict[Signature, dict[str, None]] = {}
@@ -473,21 +470,18 @@ def render(
         lines.append(f"{collect_errors} collection error{'' if one else 's'}, not counted below")
     for cluster, where in zip(shown, _headings(shown), strict=True):
         lines.append(_headline(cluster, where, total_failures))
-        # a cluster keyed on its diagnostic already says the difference in words, and the values under
-        # it are the ones that vary between its failures rather than the thing they share
+        # a cluster keyed on its diagnostic says the difference in words; the values are what varies inside it
         if cluster.signature.label:
             lines.append(f"    {cluster.signature.label}")
         else:
             lines.append(f"    actual:   {_side(cluster.actuals)}")
             lines.append(f"    expected: {_side(cluster.expecteds)}")
     if omitted:
-        # said rather than dropped: five of eleven causes shown silently reads as "these are the
-        # causes".  "more" rather than "smaller", since equal-sized clusters are ordered by signature
+        # said rather than dropped: "five of eleven" silently reads as "these are the causes".  "more" rather
+        # than "smaller", since equal-sized clusters are ordered by signature
         lines.append(f"{len(omitted)} more cluster{'' if len(omitted) == 1 else 's'} not shown")
     covered = len({nodeid for cluster in found for nodeid in cluster.nodeids})
     if covered < total_failures:
-        # what the number measures, rather than "not clustered": two tests that share a difference under
-        # a floor of three are related, and the summary declined to print them, which is not the same as
-        # having found nothing about them
+        # what the number measures, not "not clustered": the summary declined to print a pair under the floor
         lines.append(f"{total_failures - covered} of {total_failures} outside any cluster of {minimum}")
     return lines

{assertpy2-2.23.0 → assertpy2-2.24.0}/assertpy2/_dangling.py

@@ -40,7 +40,7 @@ from __future__ import annotations
 import ast
 import io
 import tokenize
-from typing import TYPE_CHECKING, Final, NamedTuple
+from typing import Final, NamedTuple
 
 from ._engine._operations import (
     ALSO_ASSERTS,
@@ -52,9 +52,6 @@ from ._engine._operations import (
     WITHOUT_A_VERDICT,
 )
 
-if TYPE_CHECKING:
-    from collections.abc import Iterator
-
 __tracebackhide__ = True
 
 # the builder factories and only those: everything else either asserts by itself or is not an entry point
@@ -128,33 +125,67 @@ class _Bindings(NamedTuple):
         return bool(self.direct or self.modules)
 
 
-def _rebound(tree: ast.Module) -> frozenset[str]:
-    """Names this module binds itself, whatever it also imported under them.
+class _Survey(NamedTuple):
+    """Everything the checks need out of the tree, gathered in one walk.
+
+    Six separate walks were measured before this: resolving the entry points, the names the module
+    rebinds, the same two again for `pytest`, the blocks that demand a raise, and the statements that
+    consume a builder.  Each is cheap on its own and the tree is walked whole every time, which came to
+    624 ms over this repository's own 97 test modules against 166 ms of parsing.
+
+    `statements` carries the scope each one sits in, as the chain of names around it.  A chain rather
+    than one name because a bare name does not identify a test: two classes in one file may each define
+    `test_same`, and matching on the name alone handed both findings to whichever ran first.
+    """
+
+    rebound: frozenset[str]
+    imports: tuple[ast.Import | ast.ImportFrom, ...]
+    blocks: tuple[ast.With | ast.AsyncWith, ...]
+    statements: tuple[tuple[ast.Expr | ast.Assert, tuple[str, ...]], ...]
+
+
+def _survey(tree: ast.Module) -> _Survey:
+    """Walk once, keeping the four things the checks ask about.
 
-    A fixture parameter named `assert_that`, a local `assert_that = lambda ...`, a module-level
-    rebinding: in each of those the call in the body is not this library's, and reporting it is a false
-    alarm on somebody else's function.
+    The walk is its own rather than `ast.walk` because the scope chain has to be carried down, and
+    `ast.walk` hands back a flat stream with no way to know what encloses what.
 
-    Deliberately module-wide rather than scope-aware.  One shadowed parameter disables the check for
-    that name across the file, which costs findings and cannot invent them, and the alternative is a
-    scope tracker inside what is meant to stay a small static pass.
+    Two statements consume a builder on the spot.  An expression statement discards the value, and
+    anywhere else it is bound, passed or returned, where whether *that* asserts is not a question about
+    this statement.  An `assert` reads it for its truth, which a builder and a bound method answer the
+    same way whatever the value is.
     """
-    names: set[str] = set()
-    for node in ast.walk(tree):
-        if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Store):
-            names.add(node.id)
-        elif isinstance(node, ast.arg):
-            names.add(node.arg)
-        # merging the identical branches is what ruff asks for and a type checker then rejects, since only the
-        # separate branch narrows `ExceptHandler.name`
-        elif isinstance(node, ast.ExceptHandler) and node.name:  # noqa: SIM114
-            names.add(node.name)
-        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
-            names.add(node.name)
-    return frozenset(names)
-
-
-def _bindings(tree: ast.Module, extra: frozenset[str] = frozenset()) -> _Bindings:
+    rebound: set[str] = set()
+    imports: list[ast.Import | ast.ImportFrom] = []
+    blocks: list[ast.With | ast.AsyncWith] = []
+    statements: list[tuple[ast.Expr | ast.Assert, tuple[str, ...]]] = []
+    stack: list[tuple[ast.AST, tuple[str, ...]]] = [(tree, ())]
+    while stack:
+        node, scope = stack.pop()
+        for child in ast.iter_child_nodes(node):
+            inner = scope
+            if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+                rebound.add(child.name)
+                inner = (*scope, child.name)
+            elif isinstance(child, ast.Expr | ast.Assert):
+                statements.append((child, scope))
+            elif isinstance(child, ast.Name):
+                if isinstance(child.ctx, ast.Store):
+                    rebound.add(child.id)
+            elif isinstance(child, ast.arg):
+                rebound.add(child.arg)
+            # merging the branches is what ruff asks and a checker rejects: only the separate one narrows the name
+            elif isinstance(child, ast.ExceptHandler) and child.name:
+                rebound.add(child.name)
+            elif isinstance(child, (ast.Import, ast.ImportFrom)):
+                imports.append(child)
+            elif isinstance(child, (ast.With, ast.AsyncWith)):
+                blocks.append(child)
+            stack.append((child, inner))
+    return _Survey(frozenset(rebound), tuple(imports), tuple(blocks), tuple(statements))
+
+
+def _bindings(survey: _Survey, extra: frozenset[str] = frozenset()) -> _Bindings:
     """Resolve how this module spells the entry points, `as` aliases and star imports included.
 
     A module that never imports one is skipped whole: a user function of their own named
@@ -168,7 +199,7 @@ def _bindings(tree: ast.Module, extra: frozenset[str] = frozenset()) -> _Binding
     """
     direct: set[str] = set()
     modules: set[str] = set()
-    for node in ast.walk(tree):
+    for node in survey.imports:
         if isinstance(node, ast.ImportFrom):
             ours = (node.module or "").split(".")[0] == _PACKAGE
             for alias in node.names:
@@ -176,11 +207,11 @@ def _bindings(tree: ast.Module, extra: frozenset[str] = frozenset()) -> _Binding
                     direct |= _ENTRY  # the docs' own preamble; a star import binds every entry point
                 elif alias.name in extra or (ours and alias.name in _ENTRY):
                     direct.add(alias.asname or alias.name)
-        elif isinstance(node, ast.Import):
+        else:
             for alias in node.names:
                 if alias.name.split(".")[0] == _PACKAGE:
                     modules.add(alias.asname or alias.name.split(".")[0])
-    shadowed = _rebound(tree)
+    shadowed = survey.rebound
     return _Bindings(frozenset(direct) - shadowed, frozenset(modules) - shadowed)
 
 
@@ -287,28 +318,92 @@ def _closed(node: ast.expr) -> bool:
     )
 
 
-def _statements(tree: ast.Module) -> Iterator[tuple[ast.Expr | ast.Assert, tuple[str, ...]]]:
-    """Every statement that consumes a builder on the spot, with the scope it sits in.
+_DEMANDS_A_RAISE: Final = frozenset({"raises", "RaisesGroup"})
+"""The `pytest` blocks that fail when their body reaches the end without raising.
 
-    Two do.  An expression statement discards the value, and anywhere else it is bound, passed or
-    returned, where whether *that* asserts is not a question about this statement.  An `assert` reads
-    it for its truth, which a builder and a bound method answer the same way whatever the value is.
+`warns` and `deprecated_call` are deliberately not here.  They expect their body to finish normally,
+so a chain that asserts nothing inside one is as silent as it would be anywhere else.  Measured: a
+`pytest.warns` block whose body warns and then dangles passes.
+"""
+
+
+def _imported_as(survey: _Survey, package: str, wanted: frozenset[str]) -> tuple[frozenset[str], frozenset[str]]:
+    """How this module spells names from *package*: bare after an import, and dotted through it.
+
+    Resolved rather than matched on the bare name, for the reason `_bindings` resolves this library's
+    own: a project helper that happens to be called `raises` or `fail` is not this one, and trusting
+    the name alone would silence a real finding inside it.
+
+    Three ways a spelling stops being the package's, all of them dropped:
+
+    * the module rebinds it, which the survey's `rebound` set answers
+    * another import binds the same spelling, where which one wins is the order they are written in
+      rather than anything a name can be read for
+    * it comes from somewhere else entirely
 
-    The scope is a chain rather than one name because a bare name does not identify a test: two classes
-    in one file may each define `test_same`, and matching on the name alone handed both findings to
-    whichever ran first.  Classes are walked for the same reason, so the chain reads
-    ``("TestOne", "test_same")``.
+    What this cannot answer is a mutation at run time.  `pytest.raises = something_else` leaves the
+    import reading exactly as it does here, and no static pass sees past that.  The boundary is the
+    spelling, not the object it will hold.
     """
-    stack: list[tuple[ast.AST, tuple[str, ...]]] = [(tree, ())]
-    while stack:
-        node, scope = stack.pop()
-        for child in ast.iter_child_nodes(node):
-            if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
-                stack.append((child, (*scope, child.name)))
-            else:
-                if isinstance(child, ast.Expr | ast.Assert):
-                    yield child, scope
-                stack.append((child, scope))
+    direct: set[str] = set()
+    modules: set[str] = set()
+    elsewhere: set[str] = set()
+    for node in survey.imports:
+        if isinstance(node, ast.ImportFrom):
+            ours = (node.module or "").split(".")[0] == package
+            for alias in node.names:
+                bound = alias.asname or alias.name
+                (direct if ours and alias.name in wanted else elsewhere).add(bound)
+        else:
+            for alias in node.names:
+                bound = alias.asname or alias.name.split(".")[0]
+                (modules if alias.name.split(".")[0] == package else elsewhere).add(bound)
+    taken = survey.rebound | elsewhere
+    return frozenset(direct - taken), frozenset(modules - taken)
+
+
+def _names_a_call(node: ast.expr, names: tuple[frozenset[str], frozenset[str]], wanted: frozenset[str]) -> bool:
+    """Whether this call reaches one of *wanted* through the imports *names* resolved."""
+    if not isinstance(node, ast.Call):
+        return False
+    direct, modules = names
+    func = node.func
+    if isinstance(func, ast.Attribute):
+        return func.attr in wanted and isinstance(func.value, ast.Name) and func.value.id in modules
+    return isinstance(func, ast.Name) and func.id in direct
+
+
+def _demands_a_raise(node: ast.With | ast.AsyncWith, names: tuple[frozenset[str], frozenset[str]]) -> bool:
+    """Whether this block fails when its body reaches the end quietly, and nothing else can end it.
+
+    One item only.  A sibling manager gets its `__exit__` run after the body, so
+    ``with pytest.raises(TypeError), Boom():`` is satisfied by `Boom` and the body never had to raise.
+    """
+    return len(node.items) == 1 and _names_a_call(node.items[0].context_expr, names, _DEMANDS_A_RAISE)
+
+
+def _only_statement_of_a_raising_block(survey: _Survey) -> frozenset[int]:
+    """The statements a `pytest.raises` block holds alone, by object identity.
+
+    The exemption is this narrow because every wider one measured unsound.  A body of one statement
+    leaves the argument with nothing to hide behind: that statement runs, and either it raises, which
+    is what the test asserts, or the block itself raises `DID NOT RAISE`.
+
+    What the block raises is where the promise stops.  An enclosing `try` that catches it, or a
+    `finally` that returns, leaves the test green again, and no check reading one statement can see
+    that.  The guarantee is about the immediate block, not about the test around it.
+
+    Each condition is here for a shape that passed silently without it.  A second statement can supply
+    the exception instead (`assert_that(x)` then `raise TypeError`), or make the chain unreachable
+    (`raise TypeError` then the chain).  A sibling `with` item can raise from its own `__exit__`.
+
+    Keyed on `id()` rather than on a line, because two statements share a line when they are written
+    `assert_that(x); raise TypeError`, and exempting the line would exempt the chain as well.
+    """
+    names = _imported_as(survey, "pytest", _DEMANDS_A_RAISE)
+    return frozenset(
+        id(node.body[0]) for node in survey.blocks if len(node.body) == 1 and _demands_a_raise(node, names)
+    )
 
 
 def _marked_lines(source: str) -> frozenset[int]:
@@ -321,7 +416,13 @@ def _marked_lines(source: str) -> frozenset[int]:
 
     A file that tokenises differently from how it parsed yields nothing rather than raising: the parse
     already succeeded, so the check goes on without the escape hatch instead of taking the run down.
+
+    The text search in front is only to decide whether to tokenise at all.  A file without the marker's
+    words anywhere cannot have it in a comment either, and two of this repository's 97 test modules
+    carry one, so tokenising all 97 was 278 ms spent to read two.
     """
+    if ALLOW_MARKER not in source:
+        return frozenset()
     try:
         tokens = tokenize.generate_tokens(io.StringIO(source).readline)
         return frozenset(one.start[0] for one in tokens if one.type == tokenize.COMMENT and ALLOW_MARKER in one.string)
@@ -353,13 +454,15 @@ def findings(source: str, path: str, extra_entries: frozenset[str] = frozenset()
         SyntaxError: if *source* does not parse; the caller decides whether that is its problem.
     """
     tree = ast.parse(source)
-    bindings = _bindings(tree, extra_entries)
+    survey = _survey(tree)
+    bindings = _bindings(survey, extra_entries)
     if not bindings:
         return []
     marked = _marked_lines(source)
+    alone = _only_statement_of_a_raising_block(survey)
     found: list[Finding] = []
-    for statement, scope in _statements(tree):
-        if _silenced(statement, marked):
+    for statement, scope in survey.statements:
+        if _silenced(statement, marked) or id(statement) in alone:
             continue
         if isinstance(statement, ast.Assert):
             if _reads_a_truthy_chain(statement.test, bindings):