sarj-python-lint 0.79.0__tar.gz → 0.80.0__tar.gz

{sarj_python_lint-0.79.0 → sarj_python_lint-0.80.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 0.79.0
+Version: 0.80.0
 Summary: Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults
 Project-URL: Homepage, https://code-standards.sarj.ai/rules/python/
 Project-URL: Documentation, https://code-standards.sarj.ai/rules/python/
@@ -17,6 +17,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: >=3.14
+Requires-Dist: ruff>=0.16.3
 Description-Content-Type: text/markdown
 
 <!-- Generated by `code-standards maintain docs sync`; do not edit. -->

{sarj_python_lint-0.79.0 → sarj_python_lint-0.80.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sarj-python-lint"
-version = "0.79.0"
+version = "0.80.0"
 description = "Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults"
 readme = "README.md"
 authors = [{ name = "sarj-ai" }]
@@ -15,7 +15,7 @@ classifiers = [
   "Programming Language :: Python :: 3.14",
   "Topic :: Software Development :: Quality Assurance",
 ]
-dependencies = []
+dependencies = ["ruff>=0.16.3"]
 
 [project.scripts]
 sarj-python-lint = "sarj_python_lint.__main__:main"

{sarj_python_lint-0.79.0 → sarj_python_lint-0.80.0}/src/sarj_python_lint/_ratchet_cli.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
 import argparse
+import json
 from pathlib import Path
+import subprocess  # ruff: ignore[suspicious-subprocess-import] -- fixed local Ruff introspection only
 import sys
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, TypeGuard
 
 from sarj_python_lint._filesystem import atomic_write_text
 from sarj_python_lint._version import __version__
@@ -93,7 +95,17 @@ def main(argv: list[str] | None = None) -> int:
         file_exceptions=baseline.file_exceptions,
         excluded_subtrees=excluded_subtrees,
     )
-    measurement = measure(root, packages, excluded_subtrees=excluded_subtrees)
+    try:
+        ruff_aliases = _ruff_selector_aliases()
+        measurement = measure(
+            root,
+            packages,
+            excluded_subtrees=excluded_subtrees,
+            ruff_aliases=ruff_aliases,
+        )
+    except (OSError, ValueError, subprocess.SubprocessError) as exc:
+        sys.stderr.write(f"sarj-ratchet: cannot measure suppressions: {exc}\n")
+        return 2
 
     if args.update:
         # A first seed has nothing to raise: every ceiling is 0 only because no
@@ -124,6 +136,42 @@ def main(argv: list[str] | None = None) -> int:
     return 0
 
 
+def _ruff_selector_aliases() -> dict[str, str]:
+    completed = subprocess.run(
+        [sys.executable, "-m", "ruff", "rule", "--all", "--output-format", "json"],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    raw: object = json.loads(completed.stdout)  # pyright: ignore[reportAny] -- validated below
+    if not _is_object_list(raw):
+        msg = "Ruff rule catalog was not a JSON list"
+        raise TypeError(msg)
+    aliases: dict[str, str] = {}
+    for raw_item in raw:
+        if not _is_string_object_mapping(raw_item):
+            msg = "Ruff rule catalog contains a non-object entry"
+            raise TypeError(msg)
+        code = raw_item.get("code")
+        name = raw_item.get("name")
+        if not isinstance(code, str) or not isinstance(name, str):
+            msg = "Ruff rule catalog entry lacks a string code or name"
+            raise TypeError(msg)
+        canonical = code.upper()
+        aliases[canonical] = canonical
+        aliases[name.lower()] = canonical
+    return aliases
+
+
+def _is_object_list(value: object) -> TypeGuard[list[object]]:
+    return isinstance(value, list)
+
+
+def _is_string_object_mapping(value: object) -> TypeGuard[dict[str, object]]:
+    # JSON object keys are strings by definition; json.loads supplied `value`.
+    return isinstance(value, dict)
+
+
 def _build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         prog="sarj-ratchet",

{sarj_python_lint-0.79.0 → sarj_python_lint-0.80.0}/src/sarj_python_lint/ratchet.py

@@ -2,8 +2,10 @@ from __future__ import annotations
 
 from collections import Counter
 from dataclasses import dataclass, field
+from io import StringIO
 import json
 import re
+import tokenize
 from types import MappingProxyType
 from typing import TYPE_CHECKING, Final, NamedTuple, TypeGuard
 
@@ -37,18 +39,28 @@ class Improvement(NamedTuple):
 
 
 DEFAULT_PER_FILE_CEILING: Final = 10
-
-_NOQA_RE: Final = re.compile(r"#\s*noqa:\s*([A-Z][A-Z0-9]+(?:\s*,\s*[A-Z][A-Z0-9]+)*)")
+BASELINE_SCHEMA_VERSION: Final = 1
+
+_RUFF_SELECTOR: Final = r"[A-Za-z][A-Za-z0-9]*(?:-[A-Za-z0-9]+)*"
+_RUFF_SELECTOR_LIST: Final = rf"({_RUFF_SELECTOR}(?:\s*,\s*{_RUFF_SELECTOR})*)"
+_NOQA_RE: Final = re.compile(rf"#\s*noqa(?::\s*{_RUFF_SELECTOR_LIST})?", re.IGNORECASE)
+_RUFF_IGNORE_RE: Final = re.compile(rf"#\s*ruff:\s*ignore\s*\[{_RUFF_SELECTOR_LIST}(?:\s*,)?\s*\]", re.IGNORECASE)
+_RUFF_FILE_IGNORE_RE: Final = re.compile(
+    rf"^#\s*ruff:\s*file-ignore\s*\[{_RUFF_SELECTOR_LIST}(?:\s*,)?\s*\]", re.IGNORECASE
+)
+_RUFF_DISABLE_RE: Final = re.compile(rf"^#\s*ruff:\s*disable\s*\[{_RUFF_SELECTOR_LIST}(?:\s*,)?\s*\]", re.IGNORECASE)
 _SARJ_NOQA_RE: Final = re.compile(r"#\s*sarj-noqa:\s*(SARJ\d+(?:\s*,\s*SARJ\d+)*)", re.IGNORECASE)
 _PYRIGHT_IGNORE_RE: Final = re.compile(r"#\s*pyright:\s*ignore\[([^\]]+)\]")
 _TYPE_IGNORE_RE: Final = re.compile(r"#\s*type:\s*ignore(?:\[([^\]]+)\])?")
-_FILE_NOQA_RE: Final = re.compile(
-    r"^\s*#\s*ruff:\s*noqa(?::\s*([A-Z][A-Z0-9]+(?:\s*,\s*[A-Z][A-Z0-9]+)*))?", re.IGNORECASE
-)
-_FILE_PYRIGHT_RE: Final = re.compile(r"^\s*#\s*pyright:\s*(?!ignore\b)")
+_FILE_NOQA_RE: Final = re.compile(rf"^#\s*ruff:\s*noqa(?::\s*{_RUFF_SELECTOR_LIST})?", re.IGNORECASE)
+_FLAKE8_FILE_NOQA_RE: Final = re.compile(r"^#\s*flake8:\s*noqa\b", re.IGNORECASE)
+_FILE_PYRIGHT_RE: Final = re.compile(r"^#\s*pyright:(?!\s*ignore\b)\s*")
 _FILE_PYRIGHT_RULE_RE: Final = re.compile(r"([A-Za-z]\w*)\s*=\s*false")
 
 _BLANKET_KEY: Final = "file-noqa:<blanket>"
+_INLINE_BLANKET_KEY: Final = "noqa:<blanket>"
+_FLAKE8_BLANKET_KEY: Final = "file-noqa:<blanket>"
+_BARE_PYRIGHT_IGNORE_KEY: Final = "pyright:<blanket>"
 _BARE_TYPE_IGNORE_KEY: Final = "type-ignore"
 
 
@@ -111,6 +123,7 @@ def measure(
     *,
     excluded_dir_names: frozenset[str] = DEFAULT_EXCLUDED_DIR_NAMES,
     excluded_subtrees: Iterable[str] = (),
+    ruff_aliases: Mapping[str, str] | None = None,
 ) -> Measurement:
     codes: Counter[str] = Counter()
     package_counts: Counter[str] = Counter()
@@ -122,7 +135,7 @@ def measure(
             relative = path.relative_to(root).as_posix()
             if any(_inside_subtree(relative, subtree) for subtree in excluded):
                 continue
-            found = count_source(_read(path))
+            found = count_source(_read(path), ruff_aliases=ruff_aliases)
             if not found:
                 continue
             codes.update(found)
@@ -132,10 +145,15 @@ def measure(
     return Measurement(codes=codes, packages=package_counts, files=files)
 
 
-def count_source(source: str) -> Counter[str]:
+def count_source(source: str, *, ruff_aliases: Mapping[str, str] | None = None) -> Counter[str]:
     counts: Counter[str] = Counter()
-    for line in source.splitlines():
-        _count_line(line, counts)
+    lines = source.splitlines()
+    for token in tokenize.generate_tokens(StringIO(source).readline):
+        if token.type != tokenize.COMMENT:
+            continue
+        line = lines[token.start[0] - 1] if token.start[0] <= len(lines) else ""
+        standalone = not line[: token.start[1]].strip()
+        _count_comment(token.string, counts, standalone=standalone, ruff_aliases=ruff_aliases)
     return counts
 
 
@@ -183,6 +201,10 @@ def load_baseline(path: Path) -> Baseline:
     raw: object = json.loads(  # pyright: ignore[reportAny] — json.loads is an untyped stdlib boundary; every read below narrows
         path.read_text(encoding="utf-8")
     )
+    schema = _get(raw, "schema_version")
+    if schema is not None and schema != BASELINE_SCHEMA_VERSION:
+        msg = f"unsupported suppression baseline schema_version: {schema!r}"
+        raise ValueError(msg)
     files = _get(raw, "files")
     ceiling = _get(files, "per_file_ceiling")
     return Baseline(
@@ -204,6 +226,7 @@ def _get(mapping: object, key: str) -> object:
 
 def dump_baseline(baseline: Baseline, packages: Iterable[str]) -> str:
     payload = {
+        "schema_version": BASELINE_SCHEMA_VERSION,
         "_comment": (
             "Suppression ceilings, written by `sarj-ratchet --update`. Counts may "
             "only go DOWN: `codes` is per dialect+code, `packages` is per "
@@ -283,27 +306,77 @@ def _read(path: Path) -> str:
 
 
 def _count_line(line: str, counts: Counter[str]) -> None:
-    if file_noqa := _FILE_NOQA_RE.match(line):
+    for token in tokenize.generate_tokens(StringIO(line).readline):
+        if token.type == tokenize.COMMENT:
+            _count_comment(
+                token.string,
+                counts,
+                standalone=not line[: token.start[1]].strip(),
+                ruff_aliases=None,
+            )
+
+
+def _count_comment(
+    comment: str,
+    counts: Counter[str],
+    *,
+    standalone: bool,
+    ruff_aliases: Mapping[str, str] | None,
+) -> None:
+    if standalone and (file_ignore := _RUFF_FILE_IGNORE_RE.match(comment)):
+        counts.update(
+            f"file-noqa:{_normalized_ruff_selector(code, ruff_aliases)}" for code in file_ignore.group(1).split(",")
+        )
+        return
+    if standalone and (file_noqa := _FILE_NOQA_RE.match(comment)):
         listed = file_noqa.group(1)
         if listed:
-            counts.update(f"file-noqa:{code.strip().upper()}" for code in listed.split(","))
+            counts.update(f"file-noqa:{_normalized_ruff_selector(code, ruff_aliases)}" for code in listed.split(","))
         else:
             counts[_BLANKET_KEY] += 1
         return
-    if _FILE_PYRIGHT_RE.match(line):
-        rules: list[str] = _FILE_PYRIGHT_RULE_RE.findall(line)
+    if standalone and _FLAKE8_FILE_NOQA_RE.match(comment):
+        counts[_FLAKE8_BLANKET_KEY] += 1
+        return
+    if standalone and (disabled := _RUFF_DISABLE_RE.match(comment)):
+        counts.update(
+            f"ruff-range:{_normalized_ruff_selector(code, ruff_aliases)}" for code in disabled.group(1).split(",")
+        )
+        return
+    if standalone and _FILE_PYRIGHT_RE.match(comment):
+        rules: list[str] = _FILE_PYRIGHT_RULE_RE.findall(comment)
         counts.update(f"file-pyright:{rule}" for rule in rules)
         return
-    for pattern, prefix in (
-        (_NOQA_RE, "noqa:"),
-        (_SARJ_NOQA_RE, "sarj-noqa:"),
-        (_PYRIGHT_IGNORE_RE, "pyright:"),
-    ):
-        for match in pattern.finditer(line):
-            counts.update(f"{prefix}{code.strip()}" for code in match.group(1).split(","))
-    for match in _TYPE_IGNORE_RE.finditer(line):
+    for match in _NOQA_RE.finditer(comment):
+        listed = match.group(1)
+        if listed:
+            counts.update(f"noqa:{_normalized_ruff_selector(code, ruff_aliases)}" for code in listed.split(","))
+        else:
+            counts[_INLINE_BLANKET_KEY] += 1
+    for match in _RUFF_IGNORE_RE.finditer(comment):
+        prefix = "standalone-noqa:" if standalone else "noqa:"
+        counts.update(f"{prefix}{_normalized_ruff_selector(code, ruff_aliases)}" for code in match.group(1).split(","))
+    for match in _SARJ_NOQA_RE.finditer(comment):
+        counts.update(f"sarj-noqa:{code.strip().upper()}" for code in match.group(1).split(","))
+    for match in _PYRIGHT_IGNORE_RE.finditer(comment):
+        counts.update(f"pyright:{code.strip()}" for code in match.group(1).split(","))
+    if re.search(r"#\s*pyright:\s*ignore\b(?!\s*\[)", comment):
+        counts[_BARE_PYRIGHT_IGNORE_KEY] += 1
+    for match in _TYPE_IGNORE_RE.finditer(comment):
         listed = match.group(1)
         if listed:
             counts.update(f"type-ignore:{code.strip()}" for code in listed.split(","))
         else:
             counts[_BARE_TYPE_IGNORE_KEY] += 1
+
+
+def _normalized_ruff_selector(selector: str, aliases: Mapping[str, str] | None) -> str:
+    stripped = selector.strip()
+    normalized = stripped.upper() if stripped.isupper() else stripped.lower()
+    if aliases is None:
+        return normalized
+    try:
+        return aliases[normalized]
+    except KeyError as exc:
+        msg = f"unknown Ruff suppression selector: {stripped}"
+        raise ValueError(msg) from exc

{sarj_python_lint-0.79.0 → sarj_python_lint-0.80.0}/src/sarj_python_lint/rules/_registry.py

@@ -111,6 +111,7 @@ from sarj_python_lint.rules.prefer_struct_over_namedtuple import (
 from sarj_python_lint.rules.prefer_timedelta_for_durations import (
     PreferTimedeltaForDurations,
 )
+from sarj_python_lint.rules.prefer_walrus_awaited_none_guard import PreferWalrusAwaitedNoneGuard
 from sarj_python_lint.rules.prefer_walrus_comprehension_filter import (
     PreferWalrusComprehensionFilter,
 )
@@ -162,6 +163,7 @@ if TYPE_CHECKING:
 
 REGISTRY: Mapping[str, type[Rule]] = MappingProxyType(
     {
+        PreferWalrusAwaitedNoneGuard.id: PreferWalrusAwaitedNoneGuard,
         TimestampOrderRequiresTiebreaker.id: TimestampOrderRequiresTiebreaker,
         NoStringConcatInLoop.id: NoStringConcatInLoop,
         PreferClassRow.id: PreferClassRow,

{sarj_python_lint-0.79.0 → sarj_python_lint-0.80.0}/src/sarj_python_lint/rules/no_raw_connection_in_tests.py

@@ -15,7 +15,7 @@ from sarj_python_lint.rule_base import (
     RuleExample,
     parse_or_none,
 )
-from sarj_python_lint.rules._paths import is_generated, is_test_path
+from sarj_python_lint.rules._paths import is_generated, is_test_path, is_test_support_path
 
 
 if TYPE_CHECKING:
@@ -42,8 +42,9 @@ class NoRawConnectionInTests(Rule):
         category=RuleCategory.TESTING,
         autofix=AutofixPolicy.NONE,
         limitations=(
-            "Only test paths are inspected.",
+            "Only test paths outside conftest.py and conventional shared test-support modules are inspected.",
             "A receiver is reported only when a parameter, annotated local, or constructor call proves it is a psycopg ConnectionPool or AsyncConnectionPool.",
+            "Pytest fixtures may use a connection internally for setup and cleanup, but fixtures that return or yield the connection remain reportable.",
         ),
         examples=(
             RuleExample(
@@ -80,7 +81,12 @@ class NoRawConnectionInTests(Rule):
 
     @override
     def check(self, path: Path, source: str) -> list[Diagnostic]:
-        if not is_test_path(path) or is_generated(path, source):
+        if (
+            not is_test_path(path)
+            or path.name == "conftest.py"
+            or is_test_support_path(path)
+            or is_generated(path, source)
+        ):
             return []
         tree = parse_or_none(path, source)
         if tree is None:
@@ -109,6 +115,7 @@ class NoRawConnectionInTests(Rule):
                 and node.func.attr == "connection"
                 and isinstance(node.func.value, ast.Name)
                 and node.func.value.id in pool_names
+                and not _is_internal_fixture_connection(scope, node)
             )
         return sorted(diagnostics, key=lambda item: (item.line, item.col))
 
@@ -152,3 +159,40 @@ def _tail(node: ast.expr | None) -> str:
             return _tail(value)
         case _:
             return ""
+
+
+def _is_internal_fixture_connection(
+    scope: ast.Module | ast.FunctionDef | ast.AsyncFunctionDef, connection_call: ast.Call
+) -> bool:
+    if not isinstance(scope, (ast.FunctionDef, ast.AsyncFunctionDef)) or not _is_pytest_fixture(scope):
+        return False
+    context_item = next(
+        (
+            item
+            for node in _scope_nodes(scope)
+            if isinstance(node, (ast.With, ast.AsyncWith))
+            for item in node.items
+            if item.context_expr is connection_call
+        ),
+        None,
+    )
+    if context_item is None:
+        return False
+    if context_item.optional_vars is None:
+        return True
+    if not isinstance(context_item.optional_vars, ast.Name):
+        return False
+    bound_name = context_item.optional_vars.id
+    return not any(
+        isinstance(node, (ast.Return, ast.Yield, ast.YieldFrom))
+        and node.value is not None
+        and any(isinstance(value, ast.Name) and value.id == bound_name for value in ast.walk(node.value))
+        for node in _scope_nodes(scope)
+    )
+
+
+def _is_pytest_fixture(scope: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
+    return any(
+        _tail(decorator.func if isinstance(decorator, ast.Call) else decorator) == "fixture"
+        for decorator in scope.decorator_list
+    )

sarj_python_lint-0.80.0/src/sarj_python_lint/rules/prefer_walrus_awaited_none_guard.py

@@ -0,0 +1,294 @@
+from __future__ import annotations
+
+import ast
+from io import StringIO
+from itertools import pairwise
+from pathlib import PurePosixPath
+import tokenize
+from typing import TYPE_CHECKING, ClassVar, NamedTuple, final, override
+
+from sarj_python_lint.rule_base import (
+    AutofixPolicy,
+    Diagnostic,
+    ExampleFile,
+    ExampleOutcome,
+    Rule,
+    RuleCategory,
+    RuleDocumentation,
+    RuleExample,
+    Severity,
+    is_suppressed,
+    parse_or_none,
+)
+from sarj_python_lint.rules._paths import is_generated
+
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+_MAX_COMBINED_LINE_LENGTH = 120
+
+
+class _WalrusCandidate(NamedTuple):
+    name: str
+    awaited: ast.Await
+
+
+@final
+class PreferWalrusAwaitedNoneGuard(Rule):
+    id = "prefer-walrus-awaited-none-guard"
+    code = "SARJ432"
+    documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
+        summary="Bind a compact awaited lookup in its immediately following None guard.",
+        rationale=(
+            "When an awaited lookup and its mandatory absence guard are adjacent, binding in the condition keeps "
+            "the operation and the reason for the temporary name in one compact expression."
+        ),
+        remediation=(
+            "Rewrite `value = await lookup(); if value is None: return` as "
+            "`if (value := await lookup()) is None: return`."
+        ),
+        category=RuleCategory.STYLE,
+        autofix=AutofixPolicy.NONE,
+        limitations=(
+            "Only one-line awaited calls followed immediately by an exact `is None` guard containing one return are checked.",
+            "The combined condition must fit 120 columns; comments, else branches, rebinding, generated files, and broader assignment-expression preferences are excluded.",
+        ),
+        examples=(
+            RuleExample(
+                example_id="awaited-optional-lookup",
+                title="An awaited lookup is split from its absence guard",
+                outcome=ExampleOutcome.MATCH,
+                files=(
+                    ExampleFile.python(
+                        "service.py",
+                        "async def load(store, item_id):\n"
+                        "    item = await store.get(item_id)\n"
+                        "    if item is None:\n"
+                        "        return\n"
+                        "    return item.name\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("service.py"),
+                expected_count=1,
+                public=True,
+            ),
+            RuleExample(
+                example_id="guard-bound-lookup",
+                title="The awaited lookup is bound in its absence guard",
+                outcome=ExampleOutcome.NO_MATCH,
+                files=(
+                    ExampleFile.python(
+                        "service.py",
+                        "async def load(store, item_id):\n"
+                        "    if (item := await store.get(item_id)) is None:\n"
+                        "        return\n"
+                        "    return item.name\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("service.py"),
+                expected_count=0,
+                public=True,
+            ),
+        ),
+    )
+    description = documentation.summary
+
+    @override
+    def check(self, path: Path, source: str) -> list[Diagnostic]:
+        if path.suffix == ".pyi" or is_generated(path, source):
+            return []
+        tree = parse_or_none(path, source)
+        if tree is None:
+            return []
+        source_lines = source.splitlines()
+        comment_lines = _comment_lines(source)
+        diagnostics: list[Diagnostic] = []
+        for body in _statement_lists(tree):
+            for index, (assignment, guard) in enumerate(pairwise(body)):
+                candidate = _candidate(assignment, guard, source, source_lines, comment_lines)
+                if candidate is None:
+                    continue
+                name, awaited = candidate
+                if not _used_before_rebinding(body[index + 2 :], name):
+                    continue
+                if is_suppressed(source_lines, assignment.lineno, self.code) or is_suppressed(
+                    source_lines, guard.lineno, self.code
+                ):
+                    continue
+                expression = ast.get_source_segment(source, awaited)
+                if expression is None:
+                    continue
+                diagnostics.append(
+                    Diagnostic(
+                        path=path,
+                        line=assignment.lineno,
+                        col=assignment.col_offset + 1,
+                        code=self.code,
+                        severity=Severity.WARNING,
+                        message=(
+                            f"`{name}` only separates an awaited lookup from its None guard; "
+                            f"bind it as `if ({name} := {expression.strip()}) is None:`"
+                        ),
+                    )
+                )
+        return sorted(diagnostics, key=lambda item: (item.line, item.col))
+
+
+def _candidate(
+    assignment: ast.stmt,
+    guard: ast.stmt,
+    source: str,
+    source_lines: list[str],
+    comment_lines: frozenset[int],
+) -> _WalrusCandidate | None:
+    if not (
+        isinstance(assignment, ast.Assign)
+        and len(assignment.targets) == 1
+        and isinstance(assignment.targets[0], ast.Name)
+        and isinstance(assignment.value, ast.Await)
+        and isinstance(assignment.value.value, ast.Call)
+        and assignment.end_lineno is not None
+        and assignment.lineno == assignment.end_lineno
+        and isinstance(guard, ast.If)
+        and guard.lineno == assignment.end_lineno + 1
+        and guard.col_offset == assignment.col_offset
+        and guard.test.end_lineno == guard.lineno
+        and not guard.orelse
+        and len(guard.body) == 1
+        and isinstance(guard.body[0], ast.Return)
+    ):
+        return None
+    name = assignment.targets[0].id
+    if not _is_none_guard(guard.test, name) or _loads_name(assignment.value, name) or _loads_name(guard.body[0], name):
+        return None
+    if comment_lines.intersection(range(assignment.lineno, guard.lineno + 1)):
+        return None
+    expression = ast.get_source_segment(source, assignment.value)
+    if expression is None:
+        return None
+    original_line = source_lines[assignment.lineno - 1]
+    indentation = original_line[: len(original_line) - len(original_line.lstrip())].expandtabs(8)
+    combined = f"{indentation}if ({name} := {expression.strip()}) is None:"
+    if len(combined) > _MAX_COMBINED_LINE_LENGTH:
+        return None
+    return _WalrusCandidate(name, assignment.value)
+
+
+def _is_none_guard(test: ast.expr, name: str) -> bool:
+    return (
+        isinstance(test, ast.Compare)
+        and isinstance(test.left, ast.Name)
+        and test.left.id == name
+        and len(test.ops) == 1
+        and isinstance(test.ops[0], ast.Is)
+        and len(test.comparators) == 1
+        and isinstance(test.comparators[0], ast.Constant)
+        and test.comparators[0].value is None
+    )
+
+
+def _loads_name(node: ast.AST, name: str) -> bool:
+    return any(
+        isinstance(child, ast.Name) and isinstance(child.ctx, ast.Load) and child.id == name for child in ast.walk(node)
+    )
+
+
+def _used_before_rebinding(statements: list[ast.stmt], name: str) -> bool:
+    for statement in statements:
+        usage = _NameUsage(name)
+        usage.visit(statement)
+        if usage.rebound:
+            return False
+        if usage.loaded:
+            return True
+    return False
+
+
+@final
+class _NameUsage(ast.NodeVisitor):
+    def __init__(self, name: str) -> None:
+        self.name = name
+        self.loaded = False
+        self.rebound = False
+
+    def visit_Name(self, node: ast.Name) -> None:
+        if node.id != self.name:
+            return
+        if isinstance(node.ctx, ast.Load):
+            self.loaded = True
+        elif isinstance(node.ctx, (ast.Store, ast.Del)):
+            self.rebound = True
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+        self.rebound |= node.name == self.name
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
+        self.rebound |= node.name == self.name
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> None:
+        self.rebound |= node.name == self.name
+
+    @override
+    def visit_Lambda(self, node: ast.Lambda) -> None:
+        _ = node
+
+    def visit_Import(self, node: ast.Import) -> None:
+        self.rebound |= any((alias.asname or alias.name.split(".", maxsplit=1)[0]) == self.name for alias in node.names)
+
+    def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
+        self.rebound |= any((alias.asname or alias.name) == self.name for alias in node.names)
+
+    def visit_ExceptHandler(self, node: ast.ExceptHandler) -> None:
+        if node.name == self.name:
+            self.rebound = True
+            return
+        self.generic_visit(node)
+
+    def visit_MatchAs(self, node: ast.MatchAs) -> None:
+        if node.name == self.name:
+            self.rebound = True
+            return
+        self.generic_visit(node)
+
+    def visit_MatchStar(self, node: ast.MatchStar) -> None:
+        self.rebound |= node.name == self.name
+
+    def visit_MatchMapping(self, node: ast.MatchMapping) -> None:
+        if node.rest == self.name:
+            self.rebound = True
+            return
+        self.generic_visit(node)
+
+    def visit_Global(self, node: ast.Global) -> None:
+        self.rebound |= self.name in node.names
+
+    def visit_Nonlocal(self, node: ast.Nonlocal) -> None:
+        self.rebound |= self.name in node.names
+
+
+def _statement_lists(tree: ast.AST) -> list[list[ast.stmt]]:
+    result: list[list[ast.stmt]] = []
+    for node in ast.walk(tree):
+        for field in ("body", "orelse", "finalbody"):
+            value = getattr(node, field, None)
+            if not isinstance(value, list):
+                continue
+            statements: list[ast.stmt] = []
+            for item in value:  # pyright: ignore[reportUnknownVariableType] -- AST fields are untyped lists
+                if not isinstance(item, ast.stmt):
+                    break
+                statements.append(item)
+            else:
+                if statements:
+                    result.append(statements)
+    return result
+
+
+def _comment_lines(source: str) -> frozenset[int]:
+    try:
+        tokens = tokenize.generate_tokens(StringIO(source).readline)
+        return frozenset(token.start[0] for token in tokens if token.type == tokenize.COMMENT)
+    except IndentationError, tokenize.TokenError:
+        return frozenset()