sarj-python-lint 1.7.4__tar.gz → 1.7.6__tar.gz

{sarj_python_lint-1.7.4 → sarj_python_lint-1.7.6}/PKG-INFO

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

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

sarj_python_lint-1.7.6/src/sarj_python_lint/rules/_contract_annotation.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import ast
+
+
+def annotation_reference(annotation: ast.expr) -> ast.Name | ast.Attribute | None:
+    match annotation:
+        case ast.Name() | ast.Attribute():
+            return annotation
+        case ast.Constant(value=str() as value):
+            try:
+                return annotation_reference(ast.parse(value, mode="eval").body)
+            except SyntaxError, ValueError:
+                return None
+        case ast.BinOp(left=left, op=ast.BitOr(), right=right):
+            if isinstance(left, ast.Constant) and left.value is None:
+                return annotation_reference(right)
+            if isinstance(right, ast.Constant) and right.value is None:
+                return annotation_reference(left)
+        case ast.Subscript(value=value, slice=inner):
+            if (wrapped := _nullable_inner(value, inner)) is not None:
+                return annotation_reference(wrapped)
+        case _:
+            return None
+    return None
+
+
+def _nullable_inner(wrapper: ast.expr, inner: ast.expr) -> ast.expr | None:
+    name = _tail(wrapper)
+    if name == "Optional":
+        return inner
+    if name == "Annotated" and isinstance(inner, ast.Tuple) and inner.elts:
+        return inner.elts[0]
+    if name != "Union" or not isinstance(inner, ast.Tuple):
+        return None
+    substantive = [item for item in inner.elts if not isinstance(item, ast.Constant) or item.value is not None]
+    return substantive[0] if len(substantive) == 1 else None
+
+
+def _tail(node: ast.expr) -> str | None:
+    match node:
+        case ast.Name(id=name) | ast.Attribute(attr=name):
+            return name
+        case _:
+            return None

{sarj_python_lint-1.7.4 → sarj_python_lint-1.7.6}/src/sarj_python_lint/rules/prefer_set_isdisjoint.py

@@ -52,7 +52,7 @@ class PreferSetIsdisjoint(ProjectRule):
     id = "prefer-set-isdisjoint"
     code = "SARJ431"
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
-        default_level=Severity.WARNING,
+        default_level=Severity.ERROR,
         summary="Prefer `set.isdisjoint` when a built-in set intersection is used only as a boolean predicate.",
         rationale="`isdisjoint` names the overlap predicate directly and avoids allocating an intersection that is immediately discarded.",
         remediation="Use `left.isdisjoint(right)` and negate it when the condition requires overlap.",
@@ -70,6 +70,7 @@ class PreferSetIsdisjoint(ProjectRule):
                 title="A declared set field is used only for an overlap test",
                 outcome=ExampleOutcome.MATCH,
                 files=(
+                    ExampleFile(PurePosixPath("pyproject.toml"), '[project]\nname = "example"\nversion = "0.1.0"\n'),
                     ExampleFile.python(
                         "app/policy.py",
                         "class AccessCase:\n    tags: frozenset[str]\n\ndef accepts(case: AccessCase):\n    if case.tags & {'read', 'write'}:\n        allow()\n",

{sarj_python_lint-1.7.4 → sarj_python_lint-1.7.6}/src/sarj_python_lint/rules/require_explicit_contract_implementation.py

@@ -16,8 +16,8 @@ from sarj_python_lint.rule_base import (
     Severity,
     is_suppressed,
 )
+from sarj_python_lint.rules._contract_annotation import annotation_reference
 from sarj_python_lint.rules._imports import ABC_SOURCES, TYPING_SOURCES, ImportIndex
-from sarj_python_lint.rules.require_port_for_service import annotation_tail
 
 
 if TYPE_CHECKING:
@@ -41,7 +41,7 @@ class RequireExplicitContractImplementation(ProjectRule):
         autofix=AutofixPolicy.NONE,
         limitations=(
             "Only direct constructor arguments and unreassigned local constructor results supplied to a resolvable typed parameter are checked.",
-            "Dynamic factories, containers, casts, unresolved ancestry, and third-party implementations are excluded.",
+            "Dynamic factories, containers, casts, unresolved or multiple owned ABC ancestry, and third-party implementations are excluded.",
         ),
         examples=(
             RuleExample(
@@ -238,10 +238,10 @@ class _InjectionVisitor(ast.NodeVisitor):
     def _check_argument(self, parameter: ast.arg | None, value: ast.expr, target_unit: SourceUnit) -> None:
         if parameter is None or parameter.annotation is None:
             return
-        name = annotation_tail(parameter.annotation)
-        if name is None:
+        reference = annotation_reference(parameter.annotation)
+        if reference is None:
             return
-        contract = self.project.class_for(target_unit, ast.Name(id=name, ctx=ast.Load()))
+        contract = self.project.class_for(target_unit, reference)
         if contract is None or not _is_direct_contract(contract, self.project):
             return
         origin = self._origin(value)
@@ -277,9 +277,6 @@ def _is_direct_contract(summary: ClassSummary, project: ProjectIndexSet) -> bool
         (base.module, base.name) in {("typing", "Protocol"), ("typing_extensions", "Protocol")}
         for base in summary.bases
     )
-    abc = any((base.module, base.name) == ("abc", "ABC") for base in summary.bases)
-    if not protocol and not abc:
-        return False
     unit = project.source_unit(summary.symbol.module)
     if unit is None or unit.tree is None:
         return False
@@ -289,19 +286,51 @@ def _is_direct_contract(summary: ClassSummary, project: ProjectIndexSet) -> bool
     )
     if declaration is None:
         return False
-    imports = ImportIndex.from_tree(unit.tree, module_scope_only=True)
-    return any(
-        isinstance(member, ast.FunctionDef | ast.AsyncFunctionDef)
-        and not member.name.startswith("_")
-        and (
-            protocol
-            or any(
-                imports.resolves(decorator, sources=ABC_SOURCES, symbol="abstractmethod")
-                for decorator in member.decorator_list
-            )
-        )
+    if protocol and any(
+        isinstance(member, ast.FunctionDef | ast.AsyncFunctionDef) and not member.name.startswith("_")
         for member in declaration.body
+    ):
+        return True
+    if not project.class_inherits_from(unit, summary.symbol.name, frozenset({"abc.ABC"})):
+        return False
+    return bool(_remaining_abstract_operations(summary, project, set()))
+
+
+def _remaining_abstract_operations(summary: ClassSummary, project: ProjectIndexSet, seen: set[SymbolRef]) -> set[str]:
+    if summary.symbol in seen:
+        return set()
+    seen.add(summary.symbol)
+    unit = project.source_unit(summary.symbol.module)
+    if unit is None or unit.tree is None:
+        return set()
+    declaration = next(
+        (item for item in unit.tree.body if isinstance(item, ast.ClassDef) and item.name == summary.symbol.name),
+        None,
     )
+    if declaration is None:
+        return set()
+    owned_parents = [base for base in summary.bases if project.source_unit(base.module) is not None]
+    if len(owned_parents) > 1:
+        return set()
+    abstract: set[str] = set()
+    for base in summary.bases:
+        parent_unit = project.source_unit(base.module)
+        parent = project.class_for(parent_unit, ast.Name(id=base.name, ctx=ast.Load())) if parent_unit else None
+        if parent is not None:
+            abstract.update(_remaining_abstract_operations(parent, project, seen.copy()))
+    imports = ImportIndex.from_tree(unit.tree, module_scope_only=True)
+    _apply_abstract_overrides(abstract, declaration, imports)
+    return abstract
+
+
+def _apply_abstract_overrides(abstract: set[str], declaration: ast.ClassDef, imports: ImportIndex) -> None:
+    for member in declaration.body:
+        if not isinstance(member, ast.FunctionDef | ast.AsyncFunctionDef) or member.name.startswith("_"):
+            continue
+        if any(imports.resolves(dec, sources=ABC_SOURCES, symbol="abstractmethod") for dec in member.decorator_list):
+            abstract.add(member.name)
+        else:
+            abstract.discard(member.name)
 
 
 def _inherits_contract(
@@ -326,7 +355,7 @@ def _inherits_contract(
         if ancestor is None:
             unknown = True
             continue
-        relationship = _inherits_contract(ancestor, target, project, seen)
+        relationship = _inherits_contract(ancestor, target, project, seen.copy())
         if relationship is True:
             return True
         unknown |= relationship is None

{sarj_python_lint-1.7.4 → sarj_python_lint-1.7.6}/src/sarj_python_lint/rules/require_explicit_service_contract.py

@@ -260,7 +260,7 @@ def _contract_status(
         contract = _contract_surface(declaration, source_unit, source_imports, project, set())
         surfaces.update(contract.operations)
         unknown |= contract.unresolved
-    return True if operations.intersection(surfaces) else None if unknown else False
+    return True if operations <= surfaces else None if unknown else False
 
 
 def _resolve_base(
@@ -311,7 +311,7 @@ def _contract_surface(
             return _ContractSurface(operations=frozenset(), unresolved=True)
         seen.add(symbol)
     abc = any(imports.resolves(base, sources=ABC_SOURCES, symbol="ABC") for base in declaration.bases)
-    surface: set[str] = _abstract_operations(declaration, imports) if abc else set()
+    surface: set[str] = _public_operations(declaration) if abc else set()
     unknown = False
     local_classes = (
         {item.name: item for item in unit.tree.body if isinstance(item, ast.ClassDef)}
@@ -328,16 +328,11 @@ def _contract_surface(
             unknown = True
             continue
         ancestor, ancestor_unit, ancestor_imports = resolved
-        ancestor_surface = _contract_surface(ancestor, ancestor_unit, ancestor_imports, project, seen)
+        ancestor_surface = _contract_surface(ancestor, ancestor_unit, ancestor_imports, project, seen.copy())
         surface.update(ancestor_surface.operations)
         unknown |= ancestor_surface.unresolved
     return _ContractSurface(operations=frozenset(surface), unresolved=unknown)
 
 
-def _abstract_operations(declaration: ast.ClassDef, imports: ImportIndex) -> set[str]:
-    return {
-        method.name
-        for method in class_methods(declaration)
-        if not method.name.startswith("_")
-        and any(imports.resolves(dec, sources=ABC_SOURCES, symbol="abstractmethod") for dec in method.decorator_list)
-    }
+def _public_operations(declaration: ast.ClassDef) -> set[str]:
+    return {method.name for method in class_methods(declaration) if not method.name.startswith("_")}

{sarj_python_lint-1.7.4 → sarj_python_lint-1.7.6}/src/sarj_python_lint/rules/require_public_dependency_contract.py

@@ -16,6 +16,7 @@ from sarj_python_lint.rule_base import (
     Severity,
     is_suppressed,
 )
+from sarj_python_lint.rules._contract_annotation import annotation_reference
 from sarj_python_lint.rules._imports import ABC_SOURCES, TYPING_SOURCES, ImportIndex
 from sarj_python_lint.rules._paths import is_test_path
 from sarj_python_lint.rules.require_explicit_service_contract import (
@@ -24,7 +25,6 @@ from sarj_python_lint.rules.require_explicit_service_contract import (
     operations_for_fields,
 )
 from sarj_python_lint.rules.require_port_for_service import (
-    annotation_tail,
     class_methods,
     is_data_type,
     self_stored_parameters,
@@ -136,10 +136,10 @@ class RequirePublicDependencyContract(ProjectRule):
         fields = fields_by_parameter.get(parameter.arg)
         if fields is None or parameter.annotation is None or not operations_for_fields(node, fields):
             return None
-        annotation_name = annotation_tail(parameter.annotation)
-        if annotation_name is None or annotation_name in {"Callable", "Awaitable", "Coroutine"}:
+        reference = annotation_reference(parameter.annotation)
+        if reference is None:
             return None
-        reason = _hidden_dependency(annotation_name, classes, context)
+        reason = _hidden_dependency(reference, classes, context)
         if reason is None or is_suppressed(context.source_lines, parameter.lineno, self.code):
             return None
         return Diagnostic(
@@ -152,9 +152,16 @@ class RequirePublicDependencyContract(ProjectRule):
         )
 
 
-def _hidden_dependency(name: str, classes: dict[str, ast.ClassDef], context: PythonFileContext) -> str | None:
-    if name.startswith("_") and name in classes and not is_data_type(classes[name]):
-        return f"private local contract `{name}`"
+def _hidden_dependency(
+    reference: ast.Name | ast.Attribute, classes: dict[str, ast.ClassDef], context: PythonFileContext
+) -> str | None:
+    if (
+        isinstance(reference, ast.Name)
+        and reference.id.startswith("_")
+        and reference.id in classes
+        and not is_data_type(classes[reference.id])
+    ):
+        return f"private local contract `{reference.id}`"
     project = context.session.project
     if project is None:
         return None
@@ -162,15 +169,9 @@ def _hidden_dependency(name: str, classes: dict[str, ast.ClassDef], context: Pyt
     source_unit = project.unit(context.path)
     if source_unit is None:
         return None
-    annotation = ast.Name(id=name, ctx=ast.Load())
-    summary = project.class_for(source_unit, annotation)
+    summary = project.class_for(source_unit, reference)
     if summary is None:
         return None
-    if (
-        name not in classes
-        and context.imports.resolved_qualified_name(annotation) != f"{summary.symbol.module}.{summary.symbol.name}"
-    ):
-        return None
     declaration_unit = project.source_unit(summary.symbol.module)
     if declaration_unit is None or declaration_unit.tree is None:
         return None