sarj-python-lint 1.1.1__tar.gz → 1.2.1__tar.gz

{sarj_python_lint-1.1.1 → sarj_python_lint-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 1.1.1
+Version: 1.2.1
 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-1.1.1 → sarj_python_lint-1.2.1}/pyproject.toml

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

{sarj_python_lint-1.1.1 → sarj_python_lint-1.2.1}/src/sarj_python_lint/__main__.py

@@ -160,6 +160,7 @@ _DIAGNOSTIC_PRECEDENCE = MappingProxyType(
         # still owns every fixed dictionary return when selected alone, while
         # an all-rules run emits one actionable diagnostic for this overlap.
         "SARJ447": frozenset({"SARJ008"}),
+        "SARJ457": frozenset({"SARJ045"}),
     }
 )
 
@@ -174,6 +175,7 @@ class _OwnerLocation(NamedTuple):
 
 
 def deduplicate_diagnostics(diags: list[Diagnostic], *, source: str | None = None) -> list[Diagnostic]:
+    diags = _deduplicate_test_composition(diags, source)
     codes = frozenset(diagnostic.code for diagnostic in diags)
     needs_docstring_owners = ("SARJ092" in codes and not codes.isdisjoint(_DIAGNOSTIC_PRECEDENCE["SARJ092"])) or (
         "SARJ420" in codes and not codes.isdisjoint(_DOCSTRING_PRECEDENCE_CODES)
@@ -221,6 +223,32 @@ def deduplicate_diagnostics(diags: list[Diagnostic], *, source: str | None = Non
     ]
 
 
+def _deduplicate_test_composition(diags: list[Diagnostic], source: str | None) -> list[Diagnostic]:
+    codes = {diagnostic.code for diagnostic in diags}
+    if source is None or not {"SARJ066", "SARJ457"} <= codes:
+        return diags
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return diags
+    whole_tests = {
+        (diagnostic.path, diagnostic.line): diagnostic.severity for diagnostic in diags if diagnostic.code == "SARJ066"
+    }
+    functions = [node for node in ast.walk(tree) if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))]
+
+    def redundant(diagnostic: Diagnostic) -> bool:
+        if diagnostic.code != "SARJ457":
+            return False
+        owners = [node for node in functions if node.lineno <= diagnostic.line <= (node.end_lineno or node.lineno)]
+        if not owners:
+            return False
+        owner = max(owners, key=lambda node: node.lineno)
+        severity = whole_tests.get((diagnostic.path, owner.lineno))
+        return severity is not None and (severity is Severity.ERROR or diagnostic.severity is Severity.WARNING)
+
+    return [diagnostic for diagnostic in diags if not redundant(diagnostic)]
+
+
 def _suppressed_diagnostics(
     present: dict[tuple[Path, int, int], dict[str, set[Severity]]],
 ) -> set[tuple[tuple[Path, int, int], str, Severity]]:

{sarj_python_lint-1.1.1 → sarj_python_lint-1.2.1}/src/sarj_python_lint/rules/_registry.py

@@ -145,6 +145,7 @@ 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_kwarg_heavy_call_in_test import RepeatedKwargHeavyCallInTest
 from sarj_python_lint.rules.repeated_static_call_cases import RepeatedStaticCallCases
+from sarj_python_lint.rules.repeated_test_composition import RepeatedTestComposition
 from sarj_python_lint.rules.require_keyword_only_swap_prone_params import (
     RequireKeywordOnlySwapProneParams,
 )
@@ -225,6 +226,7 @@ REGISTRY: Mapping[str, type[Rule]] = MappingProxyType(
         PytestFixtureReturnsBareTuple.id: PytestFixtureReturnsBareTuple,
         StoreGetDelegatesToBulkRead.id: StoreGetDelegatesToBulkRead,
         RepeatedKwargHeavyCallInTest.id: RepeatedKwargHeavyCallInTest,
+        RepeatedTestComposition.id: RepeatedTestComposition,
         DefectXfailRequiresExplicitStrict.id: DefectXfailRequiresExplicitStrict,
         NoFirstPartyPrivateImport.id: NoFirstPartyPrivateImport,
         NoRestatedComment.id: NoRestatedComment,

sarj_python_lint-1.2.1/src/sarj_python_lint/rules/_test_composition.py

@@ -0,0 +1,286 @@
+from __future__ import annotations
+
+import ast
+from collections import Counter
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from sarj_python_lint.rules._project_index import ProjectIndexSet, SourceUnit, SymbolRef
+
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from sarj_python_lint._file_context import PythonFileContext
+
+
+type Function = ast.FunctionDef | ast.AsyncFunctionDef
+_PORT_BASES = frozenset({"abc.ABC", "typing.Protocol", "typing_extensions.Protocol"})
+_MIN_COLLABORATORS = 2
+
+
+@dataclass(frozen=True)
+class Constructor:
+    symbol: SymbolRef
+    positional: tuple[str, ...]
+    collaborators: frozenset[str]
+
+
+@dataclass(frozen=True)
+class WiringScope:
+    parameters: frozenset[str]
+    aliases: dict[str, ast.expr]
+    blocked: frozenset[str]
+
+
+def direct_nodes(node: ast.AST) -> Iterator[ast.AST]:
+    for child in ast.iter_child_nodes(node):
+        yield child
+        if not isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef, ast.Lambda)):
+            yield from direct_nodes(child)
+
+
+def _class_owner(
+    context: PythonFileContext, expression: ast.expr, project: ProjectIndexSet
+) -> tuple[SourceUnit, ast.ClassDef] | None:
+    qualified = context.module_imports.resolved_qualified_name(expression)
+    unit = project.unit(context.path)
+    if qualified is not None:
+        module, _, name = qualified.rpartition(".")
+        unit = project.source_unit(module)
+    elif isinstance(expression, ast.Name):
+        name = expression.id
+    else:
+        return None
+    if unit is None or unit.tree is None or unit.module is None:
+        return None
+    owner = next((node for node in unit.tree.body if isinstance(node, ast.ClassDef) and node.name == name), None)
+    if owner is None:
+        return None
+    if any(
+        isinstance(node, ast.Name) and node.id == name and isinstance(node.ctx, (ast.Store, ast.Del))
+        for node in direct_nodes(unit.tree)
+    ):
+        return None
+    return unit, owner
+
+
+def constructor(context: PythonFileContext, expression: ast.expr, project: ProjectIndexSet) -> Constructor | None:
+    resolved = _class_owner(context, expression, project)
+    if resolved is None:
+        return None
+    unit, owner = resolved
+    if unit.module is None:
+        return None
+    initializer = next(
+        (node for node in owner.body if isinstance(node, ast.FunctionDef) and node.name == "__init__"), None
+    )
+    if initializer is None:
+        return None
+    parameters = (*initializer.args.posonlyargs, *initializer.args.args, *initializer.args.kwonlyargs)
+    invoked = _invoked_fields(owner)
+    stored = _stored_parameters(initializer)
+    collaborators = frozenset(
+        parameter.arg
+        for parameter in parameters
+        if parameter.annotation is not None
+        and _is_port(project, unit, parameter.annotation)
+        and stored.get(parameter.arg) in invoked
+    )
+    if len(collaborators) < _MIN_COLLABORATORS:
+        return None
+    return Constructor(
+        SymbolRef(unit.module, owner.name),
+        tuple(arg.arg for arg in (*initializer.args.posonlyargs, *initializer.args.args)[1:]),
+        collaborators,
+    )
+
+
+def _is_port(project: ProjectIndexSet, unit: SourceUnit, annotation: ast.expr) -> bool:
+    if isinstance(annotation, ast.Constant) and isinstance(annotation.value, str):
+        try:
+            annotation = ast.parse(annotation.value, mode="eval").body
+        except SyntaxError:
+            return False
+    summary = project.class_for(unit, annotation)
+    if summary is None:
+        return False
+    owner = project.source_unit(summary.symbol.module)
+    return owner is not None and project.class_inherits_from(owner, summary.symbol.name, _PORT_BASES)
+
+
+def _stored_parameters(initializer: Function) -> dict[str, str]:
+    stored: dict[str, str] = {}
+    writes = Counter(
+        node.attr
+        for node in direct_nodes(initializer)
+        if isinstance(node, ast.Attribute) and _is_self(node.value) and isinstance(node.ctx, (ast.Store, ast.Del))
+    )
+    for statement in initializer.body:
+        if isinstance(statement, ast.Assign) and len(statement.targets) == 1:
+            target, value = statement.targets[0], statement.value
+        elif isinstance(statement, ast.AnnAssign):
+            target, value = statement.target, statement.value
+        else:
+            continue
+        if (
+            isinstance(value, ast.Name)
+            and isinstance(target, ast.Attribute)
+            and _is_self(target.value)
+            and writes[target.attr] == 1
+        ):
+            stored[value.id] = target.attr
+    return stored
+
+
+def _is_self(node: ast.expr) -> bool:
+    return isinstance(node, ast.Name) and node.id == "self"
+
+
+def _invoked_fields(owner: ast.ClassDef) -> frozenset[str]:
+    invoked: set[str] = set()
+    for method in owner.body:
+        if isinstance(method, (ast.FunctionDef, ast.AsyncFunctionDef)) and method.name != "__init__":
+            invoked.update(_method_fields(method))
+    return frozenset(invoked)
+
+
+def _method_fields(method: Function) -> Iterator[str]:
+    for node in direct_nodes(method):
+        if not isinstance(node, ast.Call) or not isinstance(node.func, ast.Attribute):
+            continue
+        target = node.func.value
+        if isinstance(target, ast.Attribute) and _is_self(target.value):
+            yield target.attr
+
+
+def bindings(function: Function) -> dict[str, ast.expr]:
+    candidates: dict[str, list[ast.expr]] = {}
+    for statement in function.body:
+        if (
+            isinstance(statement, ast.Assign)
+            and len(statement.targets) == 1
+            and isinstance(statement.targets[0], ast.Name)
+        ):
+            candidates.setdefault(statement.targets[0].id, []).append(statement.value)
+        elif (
+            isinstance(statement, ast.AnnAssign)
+            and isinstance(statement.target, ast.Name)
+            and statement.value is not None
+        ):
+            candidates.setdefault(statement.target.id, []).append(statement.value)
+    writes = [
+        node.id
+        for node in direct_nodes(function)
+        if isinstance(node, ast.Name) and isinstance(node.ctx, (ast.Store, ast.Del))
+    ]
+    return {name: values[0] for name, values in candidates.items() if len(values) == 1 and writes.count(name) == 1}
+
+
+def local_names(function: Function) -> set[str]:
+    names: set[str] = set()
+    for node in direct_nodes(function):
+        if isinstance(node, ast.Name) and isinstance(node.ctx, (ast.Store, ast.Del)):
+            names.add(node.id)
+        elif 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.partition(".")[0] for alias in node.names)
+    return names
+
+
+def changed_before(function: Function, call: ast.Call) -> set[str]:
+    changed: set[str] = set()
+    for node in direct_nodes(function):
+        if not isinstance(node, (ast.Call, ast.Attribute)) or node.lineno >= call.lineno:
+            continue
+        target = node.func.value if isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute) else None
+        if isinstance(node, ast.Attribute) and isinstance(node.ctx, (ast.Store, ast.Del)):
+            target = node.value
+        if isinstance(target, ast.Name):
+            changed.add(target.id)
+    return changed
+
+
+def unalias(node: ast.expr, aliases: dict[str, ast.expr]) -> ast.expr:
+    seen: set[str] = set()
+    while isinstance(node, ast.Name) and node.id in aliases and node.id not in seen:
+        seen.add(node.id)
+        node = aliases[node.id]
+    return node
+
+
+def shadowed(node: ast.expr, names: frozenset[str]) -> bool:
+    while isinstance(node, ast.Attribute):
+        node = node.value
+    return isinstance(node, ast.Name) and node.id in names
+
+
+def wiring(
+    context: PythonFileContext,
+    project: ProjectIndexSet,
+    call: ast.Call,
+    spec: Constructor,
+    scope: WiringScope,
+) -> tuple[tuple[str, str], ...] | None:
+    if any(isinstance(arg, ast.Starred) for arg in call.args) or any(keyword.arg is None for keyword in call.keywords):
+        return None
+    if len(call.args) > len(spec.positional):
+        return None
+    values = dict(zip(spec.positional, call.args, strict=False))
+    for keyword in call.keywords:
+        if keyword.arg is None or keyword.arg in values:
+            return None
+        values[keyword.arg] = keyword.value
+    result: list[tuple[str, str]] = []
+    for name in sorted(spec.collaborators):
+        value = values.get(name)
+        if value is None or not isinstance(unalias(value, scope.aliases), (ast.Name, ast.Call)):
+            return None
+        identity = _value_key(context, project, value, scope)
+        if identity is None:
+            return None
+        result.append((name, identity))
+    return tuple(result)
+
+
+def _value_key(
+    context: PythonFileContext,
+    project: ProjectIndexSet,
+    value: ast.expr,
+    scope: WiringScope,
+    seen: frozenset[str] = frozenset(),
+) -> str | None:
+    if isinstance(value, ast.Name):
+        if value.id in seen or value.id in scope.blocked:
+            return None
+        if value.id in scope.aliases:
+            return _value_key(
+                context,
+                project,
+                scope.aliases[value.id],
+                scope,
+                seen=seen | {value.id},
+            )
+        return f"fixture:{value.id}" if value.id in scope.parameters else None
+    if isinstance(value, ast.Constant):
+        return ast.dump(value)
+    if not isinstance(value, ast.Call):
+        return None
+    callee = unalias(value.func, scope.aliases)
+    if shadowed(callee, scope.parameters | scope.blocked):
+        return None
+    owner = _class_owner(context, callee, project)
+    if owner is None or any(keyword.arg is None for keyword in value.keywords):
+        return None
+    positional = [_value_key(context, project, argument, scope, seen=seen) for argument in value.args]
+    keywords = [
+        (
+            keyword.arg,
+            _value_key(context, project, keyword.value, scope, seen=seen),
+        )
+        for keyword in value.keywords
+    ]
+    if any(key is None for key in positional) or any(key is None for _, key in keywords):
+        return None
+    return f"{owner[0].module}.{owner[1].name}:{positional!r}:{sorted(keywords)!r}"

{sarj_python_lint-1.1.1 → sarj_python_lint-1.2.1}/src/sarj_python_lint/rules/async_mock_call_without_await_assertion.py

@@ -69,7 +69,7 @@ class AsyncMockCallWithoutAwaitAssertion(Rule):
     id = "async-mock-call-without-await-assertion"
     code = "SARJ456"
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
-        default_level=Severity.WARNING,
+        default_level=Severity.ERROR,
         summary="Pair positive AsyncMock call assertions with evidence that the mock was awaited.",
         rationale=(
             "Calling an AsyncMock records a call before its coroutine is awaited. A positive call assertion can "
@@ -150,7 +150,7 @@ class AsyncMockCallWithoutAwaitAssertion(Rule):
                 line=call.lineno,
                 col=call.col_offset + 1,
                 code=self.code,
-                severity=Severity.WARNING,
+                severity=Severity.ERROR,
                 message="AsyncMock call assertions do not prove awaiting; keep this assertion and add an await assertion",
             )
             for test in _collected_tests(tree.body)

{sarj_python_lint-1.1.1 → sarj_python_lint-1.2.1}/src/sarj_python_lint/rules/mock_without_spec.py

@@ -121,7 +121,7 @@ class MockWithoutSpec(Rule):
     id: str = "mock-without-spec"
     code: str = "SARJ040"
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
-        default_level=Severity.WARNING,
+        default_level=Severity.ERROR,
         summary="Unrestricted mock permits attributes outside the collaborator contract.",
         rationale=(
             "A mock without a spec permits removed or misspelled attributes; a callable mock without autospec may "
@@ -234,7 +234,7 @@ class MockWithoutSpec(Rule):
                 col=node.col_offset + 1,
                 code=self.code,
                 message=_diagnostic_message(label),
-                severity=Severity.WARNING,
+                severity=Severity.ERROR,
             )
             for node, label in _unspecced_calls(
                 tree, names, pytest_mocker, _FileFacts.from_tree(tree), node_index=context.node_index

{sarj_python_lint-1.1.1 → sarj_python_lint-1.2.1}/src/sarj_python_lint/rules/negative_only_http_status_assertion.py

@@ -204,7 +204,7 @@ class NegativeOnlyHttpStatusAssertion(Rule):
     id = "negative-only-http-status-assertion"
     code = "SARJ408"
     documentation = RuleDocumentation(
-        default_level=Severity.WARNING,
+        default_level=Severity.ERROR,
         summary="HTTP test assertion only excludes a server error instead of identifying the intended response.",
         rationale=(
             "Authentication, routing, validation, and domain failures can all replace the intended response while "
@@ -276,7 +276,7 @@ class NegativeOnlyHttpStatusAssertion(Rule):
                     line=node.lineno,
                     col=node.col_offset + 1,
                     code=self.code,
-                    severity=Severity.WARNING,
+                    severity=Severity.ERROR,
                     message=(
                         "this assertion proves only that the response avoided a server-error outcome. Assert the "
                         "intended status and domain effect, or suppress SARJ408 with a reason when avoiding a server "

{sarj_python_lint-1.1.1 → sarj_python_lint-1.2.1}/src/sarj_python_lint/rules/no_fixed_sleep_before_assert.py

@@ -43,7 +43,7 @@ class NoFixedSleepBeforeAssert(Rule):
     id = "no-fixed-sleep-before-assert"
     code = "SARJ455"
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
-        default_level=Severity.WARNING,
+        default_level=Severity.ERROR,
         summary="Do not sleep for a fixed interval and then assert in a test.",
         rationale=(
             "A fixed sleep followed by an assertion guesses how long the code under test needs. On a loaded CI "