sarj-python-lint 0.69.1__tar.gz → 0.70.0__tar.gz

{sarj_python_lint-0.69.1 → sarj_python_lint-0.70.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sarj-python-lint
-Version: 0.69.1
+Version: 0.70.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/

{sarj_python_lint-0.69.1 → sarj_python_lint-0.70.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sarj-python-lint"
-version = "0.69.1"
+version = "0.70.0"
 description = "Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults"
 readme = "README.md"
 authors = [{ name = "sarj-ai" }]

{sarj_python_lint-0.69.1 → sarj_python_lint-0.70.0}/src/sarj_python_lint/rules/_registry.py

@@ -114,6 +114,7 @@ from sarj_python_lint.rules.pydantic_at_boundaries import PydanticAtBoundaries
 from sarj_python_lint.rules.redundant_class_docstring import RedundantClassDocstring
 from sarj_python_lint.rules.redundant_docstring import RedundantDocstring
 from sarj_python_lint.rules.redundant_module_docstring import RedundantModuleDocstring
+from sarj_python_lint.rules.repeated_static_call_cases import RepeatedStaticCallCases
 from sarj_python_lint.rules.require_keyword_only_swap_prone_params import (
     RequireKeywordOnlySwapProneParams,
 )
@@ -218,6 +219,7 @@ REGISTRY: Mapping[str, type[Rule]] = MappingProxyType(
         NegativeOnlyHttpStatusAssertion.id: NegativeOnlyHttpStatusAssertion,
         ProductionDerivedTestCases.id: ProductionDerivedTestCases,
         UncontrolledRandomnessInTest.id: UncontrolledRandomnessInTest,
+        RepeatedStaticCallCases.id: RepeatedStaticCallCases,
     }
 )
 

{sarj_python_lint-0.69.1 → sarj_python_lint-0.70.0}/src/sarj_python_lint/rules/duplicate_test_body.py

@@ -382,6 +382,15 @@ def _duplicate_groups(tree: ast.Module, source: str) -> list[list[_Shape]]:
     return found
 
 
+def duplicate_test_owner_ids(tree: ast.Module, source: str) -> frozenset[int]:
+    """Return the identities of tests participating in a SARJ066 group."""
+    try:
+        groups = _duplicate_groups(tree, source)
+    except tokenize.TokenError, IndentationError, SyntaxError, RecursionError:
+        return frozenset()
+    return frozenset(id(member.node) for group in groups for member in group)
+
+
 def _consecutive_embedded_source_groups(members: list[_Shape], positions: dict[int, int]) -> list[list[_Shape]]:
     """Keep only long uninterrupted runs of embedded-source checker tests."""
     ordered = sorted(members, key=lambda member: positions[id(member.node)])

{sarj_python_lint-0.69.1 → sarj_python_lint-0.70.0}/src/sarj_python_lint/rules/negative_only_http_status_assertion.py

@@ -21,7 +21,7 @@ from sarj_python_lint.rule_base import (
     Severity,
     parse_or_none,
 )
-from sarj_python_lint.rules._paths import is_test_path
+from sarj_python_lint.rules._paths import is_generated, is_test_path
 
 
 if TYPE_CHECKING:
@@ -138,7 +138,7 @@ class NegativeOnlyHttpStatusAssertion(Rule):
 
     @override
     def check(self, path: Path, source: str) -> list[Diagnostic]:
-        if not is_test_path(path):
+        if not is_test_path(path) or is_generated(path, source):
             return []
         tree = parse_or_none(path, source)
         if tree is None:

{sarj_python_lint-0.69.1 → sarj_python_lint-0.70.0}/src/sarj_python_lint/rules/production_derived_test_cases.py

@@ -21,7 +21,7 @@ from sarj_python_lint.rule_base import (
     Severity,
     parse_or_none,
 )
-from sarj_python_lint.rules._paths import is_test_path
+from sarj_python_lint.rules._paths import is_generated, is_test_path
 
 
 if TYPE_CHECKING:
@@ -33,7 +33,53 @@ _PARAMETRIZE_CASES_INDEX = 1
 _PARAMETRIZE_MIN_ARGS = 2
 
 
-def _imported_bindings(tree: ast.Module) -> set[str]:
+def _scope_binding_counts(statements: list[ast.stmt]) -> dict[str, int]:
+    """Count bindings in one scope without attributing nested scopes to it."""
+    counts: dict[str, int] = {}
+    stack: list[ast.AST] = [*reversed(statements)]
+    while stack:
+        node = stack.pop()
+        names: set[str] = set()
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+            names.add(node.name)
+        elif isinstance(node, (ast.Import, ast.ImportFrom)):
+            names.update(alias.asname or alias.name.split(".")[0] for alias in node.names)
+        elif isinstance(node, (ast.Assign, ast.Delete)):
+            names.update(*(_bound_target_names(target) for target in node.targets))
+        elif isinstance(node, (ast.AnnAssign, ast.AugAssign, ast.NamedExpr, ast.For, ast.AsyncFor)):
+            names.update(_bound_target_names(node.target))
+        elif isinstance(node, (ast.ExceptHandler, ast.MatchAs, ast.MatchStar)) and node.name is not None:
+            names.add(node.name)
+        elif isinstance(node, ast.MatchMapping) and node.rest is not None:
+            names.add(node.rest)
+        elif isinstance(node, (ast.With, ast.AsyncWith)):
+            names.update(
+                *(_bound_target_names(item.optional_vars) for item in node.items if item.optional_vars is not None)
+            )
+        for name in names:
+            counts[name] = counts.get(name, 0) + 1
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef, ast.Lambda)):
+            continue
+        stack.extend(reversed(list(ast.iter_child_nodes(node))))
+    return counts
+
+
+def _bound_target_names(node: ast.AST) -> set[str]:
+    match node:
+        case ast.Name(id=name):
+            return {name}
+        case ast.Tuple() | ast.List():
+            names: set[str] = set()
+            for element in node.elts:
+                names.update(_bound_target_names(element))
+            return names
+        case ast.Starred(value=value):
+            return _bound_target_names(value)
+        case _:
+            return set()
+
+
+def _imported_bindings(tree: ast.Module, binding_counts: dict[str, int]) -> set[str]:
     bindings: set[str] = set()
     for node in tree.body:
         if (
@@ -41,10 +87,33 @@ def _imported_bindings(tree: ast.Module) -> set[str]:
             and node.module is not None
             and not node.module.startswith(("test", "tests"))
         ):
-            bindings.update(alias.asname or alias.name for alias in node.names if alias.name != "*")
+            bindings.update(
+                local
+                for alias in node.names
+                if alias.name != "*" and binding_counts.get(local := alias.asname or alias.name, 0) == 1
+            )
     return bindings
 
 
+def _pytest_bindings(tree: ast.Module, binding_counts: dict[str, int]) -> tuple[set[str], set[str]]:
+    modules: set[str] = set()
+    marks: set[str] = set()
+    for node in tree.body:
+        if isinstance(node, ast.Import):
+            modules.update(
+                local
+                for alias in node.names
+                if alias.name == "pytest" and binding_counts.get(local := alias.asname or alias.name, 0) == 1
+            )
+        elif isinstance(node, ast.ImportFrom) and node.module == "pytest":
+            marks.update(
+                local
+                for alias in node.names
+                if alias.name == "mark" and binding_counts.get(local := alias.asname or alias.name, 0) == 1
+            )
+    return modules, marks
+
+
 def _direct_imported_collection(node: ast.expr, imported: set[str]) -> ast.Name | None:
     if isinstance(node, ast.Name) and node.id in imported and node.id.isupper() and not _is_registry(node.id):
         return node
@@ -79,15 +148,45 @@ def _is_imported_collection_wrapper(node: ast.Call, imported: set[str]) -> bool:
     )
 
 
-def _parametrize_cases(decorator: ast.expr) -> ast.expr | None:
+def _parametrize_cases(
+    decorator: ast.expr,
+    pytest_modules: set[str],
+    pytest_marks: set[str],
+    blocked: set[str],
+) -> ast.expr | None:
     if not isinstance(decorator, ast.Call) or len(decorator.args) < _PARAMETRIZE_MIN_ARGS:
         return None
     func = decorator.func
     if not isinstance(func, ast.Attribute) or func.attr != "parametrize":
         return None
+    owner = func.value
+    module_owned = (
+        isinstance(owner, ast.Attribute)
+        and owner.attr == "mark"
+        and isinstance(owner.value, ast.Name)
+        and owner.value.id in pytest_modules - blocked
+    )
+    mark_owned = isinstance(owner, ast.Name) and owner.id in pytest_marks - blocked
+    if not module_owned and not mark_owned:
+        return None
     return decorator.args[_PARAMETRIZE_CASES_INDEX]
 
 
+def _collected_tests(tree: ast.Module) -> list[tuple[ast.FunctionDef | ast.AsyncFunctionDef, set[str]]]:
+    tests: list[tuple[ast.FunctionDef | ast.AsyncFunctionDef, set[str]]] = []
+    for node in tree.body:
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and node.name.startswith("test_"):
+            tests.append((node, set()))
+        elif isinstance(node, ast.ClassDef) and node.name.startswith("Test"):
+            class_bindings = set(_scope_binding_counts(node.body))
+            tests.extend(
+                (child, class_bindings)
+                for child in node.body
+                if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef)) and child.name.startswith("test_")
+            )
+    return tests
+
+
 def _independently_asserted_collections(tree: ast.Module, imported: set[str]) -> set[str]:
     asserted: set[str] = set()
     for node in ast.walk(tree):
@@ -128,7 +227,7 @@ class ProductionDerivedTestCases(Rule):
                 files=(
                     ExampleFile.python(
                         "tests/test_models.py",
-                        "EXPECTED_MODELS = ('a', 'b')\n\n@pytest.mark.parametrize('model', EXPECTED_MODELS)\ndef test_model(model):\n    assert build(model).tier == 'priority'\n",
+                        "import pytest\n\nEXPECTED_MODELS = ('a', 'b')\n\n@pytest.mark.parametrize('model', EXPECTED_MODELS)\ndef test_model(model):\n    assert build(model).tier == 'priority'\n",
                     ),
                 ),
                 focus_path=PurePosixPath("tests/test_models.py"),
@@ -142,7 +241,7 @@ class ProductionDerivedTestCases(Rule):
                 files=(
                     ExampleFile.python(
                         "tests/test_models.py",
-                        "from app.models import ELIGIBLE_MODELS\n\n@pytest.mark.parametrize('model', ELIGIBLE_MODELS)\ndef test_model(model):\n    assert build(model).tier == 'priority'\n",
+                        "import pytest\nfrom app.models import ELIGIBLE_MODELS\n\n@pytest.mark.parametrize('model', ELIGIBLE_MODELS)\ndef test_model(model):\n    assert build(model).tier == 'priority'\n",
                     ),
                 ),
                 focus_path=PurePosixPath("tests/test_models.py"),
@@ -155,19 +254,19 @@ class ProductionDerivedTestCases(Rule):
 
     @override
     def check(self, path: Path, source: str) -> list[Diagnostic]:
-        if not is_test_path(path):
+        if not is_test_path(path) or is_generated(path, source):
             return []
         tree = parse_or_none(path, source)
         if tree is None:
             return []
-        imported = _imported_bindings(tree)
+        binding_counts = _scope_binding_counts(tree.body)
+        imported = _imported_bindings(tree, binding_counts)
+        pytest_modules, pytest_marks = _pytest_bindings(tree, binding_counts)
         independently_asserted = _independently_asserted_collections(tree, imported)
         findings: list[Diagnostic] = []
-        for node in ast.walk(tree):
-            if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) or not node.name.startswith("test_"):
-                continue
+        for node, blocked in _collected_tests(tree):
             for decorator in node.decorator_list:
-                cases = _parametrize_cases(decorator)
+                cases = _parametrize_cases(decorator, pytest_modules, pytest_marks, blocked)
                 if cases is None:
                     continue
                 collection = _direct_imported_collection(cases, imported)

sarj_python_lint-0.70.0/src/sarj_python_lint/rules/repeated_static_call_cases.py

@@ -0,0 +1,298 @@
+"""SARJ413 — Repeated static call assertions should be named test cases.
+
+Examples: https://github.com/sarj-ai/standards/blob/main/packages/python/tests/rules/test_repeated_static_call_cases.py
+"""
+
+from __future__ import annotations
+
+import ast
+from io import StringIO
+from pathlib import PurePosixPath
+import tokenize
+from typing import TYPE_CHECKING, final, override
+
+from sarj_python_lint.rule_base import (
+    AutofixPolicy,
+    Diagnostic,
+    ExampleFile,
+    ExampleOutcome,
+    Rule,
+    RuleCategory,
+    RuleDocumentation,
+    RuleExample,
+    Severity,
+    parse_or_none,
+)
+from sarj_python_lint.rules._paths import is_generated, is_test_path
+from sarj_python_lint.rules.duplicate_test_body import duplicate_test_owner_ids
+
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+    from pathlib import Path
+
+
+_MIN_CASES = 3
+_MIN_DISTINCT_CASES = 2
+_FUNC_NODES = (ast.FunctionDef, ast.AsyncFunctionDef)
+_ACCESSOR_CALLEES = frozenset({"get"})
+_UNSAFE_CALLEE_PARTS = frozenset({"mock", "snapshot", "spy"})
+
+
+@final
+class RepeatedStaticCallCases(Rule):
+    id = "repeated-static-call-cases"
+    code = "SARJ413"
+    documentation = RuleDocumentation(
+        summary="Repeated static call assertions are hidden inside one coarse test case.",
+        rationale=(
+            "When several independent static inputs share one test callback, the first failure hides later cases "
+            "and the runner cannot name the input that failed."
+        ),
+        remediation="Move the inputs and expectations into a named pytest parameter table.",
+        category=RuleCategory.TESTING,
+        autofix=AutofixPolicy.NONE,
+        limitations=(
+            "Only runs of at least three consecutive top-level assertions in collected pytest-style tests are checked.",
+            "Calls, inputs, and expectations must be statically representable; unittest classes, zero-argument calls, mocks, snapshots, and intervening prose or setup are excluded.",
+            "Common mapping accessors are excluded because repeated field assertions usually describe one cohesive object contract, not independent input cases.",
+            "Tests participating in a duplicate-test-body group are left to SARJ066, which has the broader finding.",
+            "Case names and parameter boundaries require judgment, so the rule has no autofix.",
+        ),
+        examples=(
+            RuleExample(
+                example_id="parameterized-parser-cases",
+                title="Give each parser input a runner-visible case",
+                outcome=ExampleOutcome.NO_MATCH,
+                files=(
+                    ExampleFile.python(
+                        "tests/test_parser.py",
+                        "@pytest.mark.parametrize(('value', 'expected'), [('a', 1), ('b', 2), ('c', 3)])\ndef test_parse(value, expected):\n    assert parse(value) == expected\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("tests/test_parser.py"),
+                expected_count=0,
+                public=True,
+            ),
+            RuleExample(
+                example_id="repeated-parser-assertions",
+                title="Do not hide independent inputs in one callback",
+                outcome=ExampleOutcome.MATCH,
+                files=(
+                    ExampleFile.python(
+                        "tests/test_parser.py",
+                        "def test_parse():\n    assert parse('a') == 1\n    assert parse('b') == 2\n    assert parse('c') == 3\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("tests/test_parser.py"),
+                expected_count=1,
+                public=True,
+            ),
+        ),
+    )
+    description = documentation.summary
+
+    @override
+    def check(self, path: Path, source: str) -> list[Diagnostic]:
+        if not is_test_path(path) or is_generated(path, source):
+            return []
+        tree = parse_or_none(path, source)
+        if tree is None:
+            return []
+        comments = _comment_lines(source)
+        duplicate_owners = duplicate_test_owner_ids(tree, source)
+        findings = [
+            Diagnostic(
+                path=path,
+                line=run[0].lineno,
+                col=run[0].col_offset + 1,
+                code=self.code,
+                severity=Severity.WARNING,
+                message=(
+                    f"these {len(run)} static call assertions run as one coarse test; move the inputs and "
+                    "expectations into named pytest parameters."
+                ),
+            )
+            for test in _test_functions(tree)
+            if id(test) not in duplicate_owners
+            for run in _runs(test, comments)
+        ]
+        return sorted(findings, key=lambda finding: (finding.line, finding.col))
+
+
+def _dotted_name(node: ast.expr) -> tuple[str, ...] | None:
+    if isinstance(node, ast.Name):
+        return (node.id,)
+    if isinstance(node, ast.Attribute):
+        parent = _dotted_name(node.value)
+        return None if parent is None else (*parent, node.attr)
+    return None
+
+
+def _comment_lines(source: str) -> frozenset[int]:
+    try:
+        return frozenset(
+            token.start[0]
+            for token in tokenize.generate_tokens(StringIO(source).readline)
+            if token.type == tokenize.COMMENT
+        )
+    except IndentationError, tokenize.TokenError:
+        return frozenset()
+
+
+def _test_functions(tree: ast.Module) -> Iterator[ast.FunctionDef | ast.AsyncFunctionDef]:
+    local_classes = {node.name: node for node in tree.body if isinstance(node, ast.ClassDef)}
+
+    def is_test_case(node: ast.ClassDef, seen: frozenset[str] = frozenset()) -> bool:
+        if node.name in seen:
+            return False
+        for base in node.bases:
+            name = _base_name(base)
+            if name is not None and name.endswith("TestCase"):
+                return True
+            if name in local_classes and is_test_case(local_classes[name], seen | {node.name}):
+                return True
+        return False
+
+    for statement in tree.body:
+        if isinstance(statement, _FUNC_NODES) and statement.name.startswith("test_"):
+            yield statement
+        elif isinstance(statement, ast.ClassDef) and not is_test_case(statement):
+            yield from (
+                child for child in statement.body if isinstance(child, _FUNC_NODES) and child.name.startswith("test_")
+            )
+
+
+def _base_name(node: ast.expr) -> str | None:
+    dotted = _dotted_name(node)
+    return None if dotted is None else dotted[-1]
+
+
+def _runs(test: ast.FunctionDef | ast.AsyncFunctionDef, comments: frozenset[int]) -> Iterator[list[ast.Assert]]:
+    current: list[ast.Assert] = []
+    current_shape: object | None = None
+    current_values: set[str] = set()
+    for statement in test.body:
+        if not isinstance(statement, ast.Assert) or _has_attached_comment(statement, comments):
+            if len(current) >= _MIN_CASES and len(current_values) >= _MIN_DISTINCT_CASES:
+                yield current
+            current, current_shape, current_values = [], None, set()
+            continue
+        parsed = _assertion_shape(statement)
+        if parsed is None:
+            if len(current) >= _MIN_CASES and len(current_values) >= _MIN_DISTINCT_CASES:
+                yield current
+            current, current_shape, current_values = [], None, set()
+            continue
+        shape, values = parsed
+        if current and (shape != current_shape or _has_intervening_comment(current[-1], statement, comments)):
+            if len(current) >= _MIN_CASES and len(current_values) >= _MIN_DISTINCT_CASES:
+                yield current
+            current, current_values = [], set()
+        current.append(statement)
+        current_shape = shape
+        current_values.add(values)
+    if len(current) >= _MIN_CASES and len(current_values) >= _MIN_DISTINCT_CASES:
+        yield current
+
+
+def _assertion_shape(node: ast.Assert) -> tuple[object, str] | None:
+    expression = node.test
+    polarity = "truthy"
+    expectation: ast.expr | None = None
+    call_expr: ast.expr
+    if isinstance(expression, ast.UnaryOp) and isinstance(expression.op, ast.Not):
+        polarity = "falsy"
+        call_expr = expression.operand
+    elif isinstance(expression, ast.Compare) and len(expression.ops) == 1 and len(expression.comparators) == 1:
+        call_expr = expression.left
+        expectation = expression.comparators[0]
+        polarity = type(expression.ops[0]).__name__
+    else:
+        call_expr = expression
+    parsed = _call(call_expr)
+    if parsed is None or (expectation is not None and not _static(expectation)):
+        return None
+    call, awaited = parsed
+    callee = _dotted_name(call.func)
+    if (
+        callee is None
+        or not _eligible_callee(callee)
+        or not call.args
+        or any(isinstance(arg, ast.Starred) or not _static(arg) for arg in call.args)
+        or any(keyword.arg is None or not _static(keyword.value) for keyword in call.keywords)
+    ):
+        return None
+    skeleton = (
+        callee,
+        awaited,
+        polarity,
+        tuple(_static_shape(arg) for arg in call.args),
+        tuple((keyword.arg, _static_shape(keyword.value)) for keyword in call.keywords),
+        None if expectation is None else _static_shape(expectation),
+    )
+    values = _static_value(ast.Tuple(elts=[*call.args, *(keyword.value for keyword in call.keywords)], ctx=ast.Load()))
+    return skeleton, values
+
+
+def _eligible_callee(callee: tuple[str, ...]) -> bool:
+    return callee[-1] not in _ACCESSOR_CALLEES and not any(
+        any(part in segment.lower() for part in _UNSAFE_CALLEE_PARTS) for segment in callee
+    )
+
+
+def _has_intervening_comment(previous: ast.Assert, current: ast.Assert, comments: frozenset[int]) -> bool:
+    return any((previous.end_lineno or previous.lineno) < line < current.lineno for line in comments)
+
+
+def _has_attached_comment(statement: ast.Assert, comments: frozenset[int]) -> bool:
+    return any(statement.lineno <= line <= (statement.end_lineno or statement.lineno) for line in comments)
+
+
+def _call(node: ast.expr) -> tuple[ast.Call, bool] | None:
+    awaited = isinstance(node, ast.Await)
+    candidate = node.value if awaited else node
+    return (candidate, awaited) if isinstance(candidate, ast.Call) else None
+
+
+def _static(node: ast.expr) -> bool:
+    match node:
+        case ast.Constant():
+            return True
+        case ast.Attribute():
+            return _dotted_name(node) is not None
+        case ast.UnaryOp(op=ast.UAdd() | ast.USub() | ast.Invert(), operand=operand):
+            return _static(operand)
+        case ast.Tuple() | ast.List() | ast.Set():
+            return all(_static(elt) for elt in node.elts)
+        case ast.Dict(keys=keys, values=values):
+            return all(key is not None and _static(key) for key in keys) and all(_static(value) for value in values)
+        case _:
+            return False
+
+
+def _static_shape(node: ast.expr) -> object:
+    match node:
+        case ast.Constant(value=value):
+            return ("constant", type(value).__name__)
+        case ast.Attribute():
+            return ("symbol", len(_dotted_name(node) or ()))
+        case ast.UnaryOp(op=op, operand=operand):
+            return (type(op).__name__, _static_shape(operand))
+        case ast.Tuple() | ast.List() | ast.Set():
+            return (type(node).__name__, tuple(_static_shape(elt) for elt in node.elts))
+        case ast.Dict(keys=keys, values=values):
+            return (
+                "Dict",
+                tuple(
+                    (_static_shape(key), _static_shape(value)) for key, value in zip(keys, values, strict=True) if key
+                ),
+            )
+        case _:
+            raise AssertionError
+
+
+def _static_value(node: ast.expr) -> str:
+    """Return a bounded comparison token without retaining a large literal."""
+    rendered = ast.dump(node, annotate_fields=False, include_attributes=False)
+    return rendered[:512]

{sarj_python_lint-0.69.1 → sarj_python_lint-0.70.0}/src/sarj_python_lint/rules/uncontrolled_randomness_in_test.py

@@ -21,7 +21,7 @@ from sarj_python_lint.rule_base import (
     Severity,
     parse_or_none,
 )
-from sarj_python_lint.rules._paths import is_test_path
+from sarj_python_lint.rules._paths import is_generated, is_test_path
 
 
 if TYPE_CHECKING:
@@ -33,16 +33,78 @@ _PRNG_FUNCTIONS = frozenset({"choice", "choices", "randint", "random", "randrang
 _REPEAT_NODES = (ast.For, ast.AsyncFor, ast.While, ast.ListComp, ast.SetComp, ast.DictComp, ast.GeneratorExp)
 
 
+def _bound_target_names(node: ast.AST) -> set[str]:
+    match node:
+        case ast.Name(id=name):
+            return {name}
+        case ast.Tuple() | ast.List():
+            names: set[str] = set()
+            for element in node.elts:
+                names.update(_bound_target_names(element))
+            return names
+        case ast.Starred(value=value):
+            return _bound_target_names(value)
+        case _:
+            return set()
+
+
+def _scope_binding_events(statements: list[ast.stmt]) -> list[str]:
+    """Return binding events in one scope without entering nested scopes."""
+    bindings: list[str] = []
+    stack: list[ast.AST] = [*reversed(statements)]
+    while stack:
+        node = stack.pop()
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+            bindings.append(node.name)
+        elif isinstance(node, (ast.Import, ast.ImportFrom)):
+            bindings.extend(alias.asname or alias.name.split(".")[0] for alias in node.names)
+        elif isinstance(node, (ast.Assign, ast.Delete)):
+            for target in node.targets:
+                bindings.extend(_bound_target_names(target))
+        elif isinstance(node, (ast.AnnAssign, ast.AugAssign, ast.NamedExpr, ast.For, ast.AsyncFor)):
+            bindings.extend(_bound_target_names(node.target))
+        elif isinstance(node, (ast.ExceptHandler, ast.MatchAs, ast.MatchStar)) and node.name is not None:
+            bindings.append(node.name)
+        elif isinstance(node, ast.MatchMapping) and node.rest is not None:
+            bindings.append(node.rest)
+        elif isinstance(node, (ast.With, ast.AsyncWith)):
+            for item in node.items:
+                if item.optional_vars is not None:
+                    bindings.extend(_bound_target_names(item.optional_vars))
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef, ast.Lambda)):
+            continue
+        stack.extend(reversed(list(ast.iter_child_nodes(node))))
+    return bindings
+
+
+def _scope_bindings(statements: list[ast.stmt]) -> set[str]:
+    return set(_scope_binding_events(statements))
+
+
+def _module_binding_counts(tree: ast.Module) -> dict[str, int]:
+    counts: dict[str, int] = {}
+    for name in _scope_binding_events(tree.body):
+        counts[name] = counts.get(name, 0) + 1
+    return counts
+
+
 def _random_aliases(tree: ast.Module) -> tuple[set[str], set[str], set[str]]:
     modules: set[str] = set()
     functions: set[str] = set()
     seeds: set[str] = set()
+    binding_counts = _module_binding_counts(tree)
     for node in tree.body:
         if isinstance(node, ast.Import):
-            modules.update(alias.asname or alias.name for alias in node.names if alias.name == "random")
+            modules.update(
+                local
+                for alias in node.names
+                if alias.name == "random" and binding_counts.get(local := alias.asname or alias.name, 0) == 1
+            )
         elif isinstance(node, ast.ImportFrom) and node.module == "random":
             for alias in node.names:
                 local = alias.asname or alias.name
+                if binding_counts.get(local, 0) != 1:
+                    continue
                 if alias.name in _PRNG_FUNCTIONS:
                     functions.add(local)
                 elif alias.name == "seed":
@@ -78,11 +140,38 @@ def _test_nodes(test: ast.FunctionDef | ast.AsyncFunctionDef) -> Iterator[ast.AS
     while stack:
         node = stack.pop()
         yield node
-        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.Lambda)):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef, ast.Lambda)):
             continue
         stack.extend(reversed(list(ast.iter_child_nodes(node))))
 
 
+def _bounded_nodes(root: ast.AST) -> Iterator[ast.AST]:
+    """Walk a subtree without entering nested callable or class scopes."""
+    stack = [root]
+    while stack:
+        node = stack.pop()
+        yield node
+        if node is not root and isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef, ast.Lambda)):
+            continue
+        stack.extend(reversed(list(ast.iter_child_nodes(node))))
+
+
+def _test_nodes_for_statement(statement: ast.stmt) -> Iterator[ast.AST]:
+    yield from _bounded_nodes(statement)
+
+
+def _collected_tests(tree: ast.Module) -> Iterator[ast.FunctionDef | ast.AsyncFunctionDef]:
+    for node in tree.body:
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and node.name.startswith("test_"):
+            yield node
+        elif isinstance(node, ast.ClassDef) and node.name.startswith("Test"):
+            yield from (
+                child
+                for child in node.body
+                if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef)) and child.name.startswith("test_")
+            )
+
+
 @final
 class UncontrolledRandomnessInTest(Rule):
     id = "uncontrolled-randomness-in-test"
@@ -99,7 +188,7 @@ class UncontrolledRandomnessInTest(Rule):
         limitations=(
             "Only standard-library `random` calls nested in loops or comprehensions in collected tests are checked.",
             "Single draws, injected RNG objects, Hypothesis tests, and cryptographic randomness are excluded.",
-            "A seed anywhere in the test suppresses the finding; interprocedural seeding is not inferred.",
+            "Only an unconditional top-level seed before the repeated sample suppresses the finding; interprocedural seeding is not inferred.",
         ),
         examples=(
             RuleExample(
@@ -136,7 +225,7 @@ class UncontrolledRandomnessInTest(Rule):
 
     @override
     def check(self, path: Path, source: str) -> list[Diagnostic]:
-        if not is_test_path(path):
+        if not is_test_path(path) or is_generated(path, source):
             return []
         tree = parse_or_none(path, source)
         if tree is None:
@@ -145,17 +234,42 @@ class UncontrolledRandomnessInTest(Rule):
         if not modules and not functions:
             return []
         findings: list[Diagnostic] = []
-        for test in ast.walk(tree):
-            if not isinstance(test, (ast.FunctionDef, ast.AsyncFunctionDef)) or not test.name.startswith("test_"):
+        for test in _collected_tests(tree):
+            local_bindings = _scope_bindings(test.body) | {
+                arg.arg for arg in (*test.args.posonlyargs, *test.args.args, *test.args.kwonlyargs)
+            }
+            if test.args.vararg is not None:
+                local_bindings.add(test.args.vararg.arg)
+            if test.args.kwarg is not None:
+                local_bindings.add(test.args.kwarg.arg)
+            test_modules = modules - local_bindings
+            test_functions = functions - local_bindings
+            test_seeds = seeds - local_bindings
+            if not test_modules and not test_functions:
                 continue
             nodes = list(_test_nodes(test))
-            if any(isinstance(node, ast.Call) and _is_seed_call(node, modules, seeds) for node in nodes):
-                continue
+            top_level_seed_indexes = {
+                index
+                for index, statement in enumerate(test.body)
+                if isinstance(statement, ast.Expr)
+                and isinstance(statement.value, ast.Call)
+                and _is_seed_call(statement.value, test_modules, test_seeds)
+            }
             for repeated in (node for node in nodes if isinstance(node, _REPEAT_NODES)):
+                owner_index = next(
+                    (
+                        index
+                        for index, statement in enumerate(test.body)
+                        if repeated is statement or repeated in _test_nodes_for_statement(statement)
+                    ),
+                    None,
+                )
+                if owner_index is not None and any(seed_index < owner_index for seed_index in top_level_seed_indexes):
+                    continue
                 calls = [
                     node
-                    for node in ast.walk(repeated)
-                    if isinstance(node, ast.Call) and _is_prng_call(node, modules, functions)
+                    for node in _bounded_nodes(repeated)
+                    if isinstance(node, ast.Call) and _is_prng_call(node, test_modules, test_functions)
                 ]
                 findings.extend(
                     Diagnostic(