sarj-python-lint 1.63.1__tar.gz → 1.66.0__tar.gz

{sarj_python_lint-1.63.1 → sarj_python_lint-1.66.0}/.gitignore

@@ -44,6 +44,9 @@ Thumbs.db
 !.claude/skills/test-value/
 .claude/skills/test-value/*
 !.claude/skills/test-value/SKILL.md
+!.claude/skills/100-passes/
+.claude/skills/100-passes/*
+!.claude/skills/100-passes/SKILL.md
 apps/docs/.wrangler/
 apps/docs/.dev.vars*
 !apps/docs/.dev.vars.example

{sarj_python_lint-1.63.1 → sarj_python_lint-1.66.0}/PKG-INFO

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

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

{sarj_python_lint-1.63.1 → sarj_python_lint-1.66.0}/src/sarj_python_lint/__main__.py

@@ -23,6 +23,7 @@ from sarj_python_lint.rule_base import Diagnostic, ProjectRule, Rule, Severity,
 from sarj_python_lint.rules import REGISTRY
 from sarj_python_lint.rules._paths import clear_path_caches
 from sarj_python_lint.rules._project_index import ProjectIndexSet
+from sarj_python_lint.suppression_policy import PROTECTED_SUPPRESSION_CODES
 
 
 SKIP_DIR_NAMES = frozenset(
@@ -46,11 +47,17 @@ SKIP_DIR_NAMES = frozenset(
     }
 )
 
-# Skip files larger than this — they are almost always generated/vendored, not
-# hand-written source worth linting.
+# Bound resource use, but never turn an unanalyzed selected file into success.
 _MAX_FILE_BYTES = 500_000
 
 
+def _checked_size(path: Path) -> Path:
+    if path.stat().st_size > _MAX_FILE_BYTES:
+        msg = f"selected Python source exceeds {_MAX_FILE_BYTES} bytes: {path}; use an explicit path exclusion for generated source"
+        raise ValueError(msg)
+    return path
+
+
 def expand_paths(paths: list[Path]) -> list[Path]:
     out: list[Path] = []
     for p in paths:
@@ -58,11 +65,7 @@ def expand_paths(paths: list[Path]) -> list[Path]:
             msg = f"input does not exist: {p}"
             raise ValueError(msg)
         if p.is_file():
-            try:
-                if p.stat().st_size <= _MAX_FILE_BYTES:
-                    out.append(p)
-            except OSError:
-                pass
+            out.append(_checked_size(p))
             continue
         out.extend(_python_files(p))
     return out
@@ -78,11 +81,8 @@ def _python_files(p: Path) -> list[Path]:
             if not fnmatch(name, "*.py"):
                 continue
             child = directory / name
-            try:
-                if child.is_file() and child.stat().st_size <= _MAX_FILE_BYTES:
-                    out.append(child)
-            except OSError:
-                continue
+            if child.is_file():
+                out.append(_checked_size(child))
     return sorted(out)
 
 
@@ -109,12 +109,7 @@ def _check(rule_ids: list[str], paths: list[Path]) -> list[Diagnostic]:
         rule.prepare_session(session)
     clear_path_caches()
     expanded = expand_paths(paths)
-    loaded: dict[Path, str] = {}
-    for path in expanded:
-        try:
-            loaded[path] = read_python_source(path)
-        except OSError:
-            continue
+    loaded = {path: read_python_source(path) for path in expanded}
     project_rules = [rule for rule in rules if isinstance(rule, ProjectRule)]
     if project_rules:
         indexes = ProjectIndexSet.build(expanded, loaded, facts=session.first_party)
@@ -131,14 +126,13 @@ def check_source(
     rules: list[Rule], p: Path, source: str, *, session: AnalysisSession | None = None
 ) -> list[Diagnostic]:
     context = PythonFileContext(p, source, session)
+    if rules and context.tree is None:
+        msg = f"selected Python source could not be parsed: {p}"
+        raise ValueError(msg)
     source_lines = context.source_lines
     raw = [diagnostic for rule in rules for diagnostic in rule.check_context(context)]
     return deduplicate_diagnostics(
-        [
-            diagnostic
-            for diagnostic in raw
-            if diagnostic.code == "SARJ419" or not is_suppressed(source_lines, diagnostic.line, diagnostic.code)
-        ],
+        [diagnostic for diagnostic in raw if not is_suppressed(source_lines, diagnostic.line, diagnostic.code)],
         source=source,
         context=context,
     )
@@ -157,6 +151,9 @@ def analyze(
 
 _DIAGNOSTIC_PRECEDENCE = MappingProxyType(
     {
+        "SARJ054": frozenset({"SARJ419"}),
+        "SARJ448": frozenset({"SARJ419"}),
+        "SARJ523": frozenset({"SARJ419"}),
         "SARJ050": frozenset({"SARJ420"}),
         "SARJ084": frozenset({"SARJ050", "SARJ420"}),
         "SARJ085": frozenset({"SARJ420"}),
@@ -417,7 +414,7 @@ def _explain(wanted: str) -> int:
 def _baseline_counts(diags: list[Diagnostic]) -> dict[str, dict[str, int]]:
     counts: dict[str, dict[str, int]] = {}
     for d in diags:
-        if d.severity is Severity.WARNING:
+        if d.severity is Severity.WARNING or d.code in PROTECTED_SUPPRESSION_CODES:
             continue
         key = _baseline_path(d.path)
         counts.setdefault(key, {})
@@ -467,7 +464,7 @@ def _apply_baseline(
     seen: Counter[tuple[str, str]] = Counter()
     out: list[Diagnostic] = []
     for d in diags:
-        if d.severity is Severity.WARNING:
+        if d.severity is Severity.WARNING or d.code in PROTECTED_SUPPRESSION_CODES:
             out.append(d)
             continue
         path_key = _baseline_path(d.path, root=root)

{sarj_python_lint-1.63.1 → sarj_python_lint-1.66.0}/src/sarj_python_lint/_file_context.py

@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING, final
 
 from sarj_python_lint._analysis_session import AnalysisSession
 from sarj_python_lint._source import symbol_prefilter_source
+from sarj_python_lint.rules._annotation_semantics import AnnotationSemantics
 from sarj_python_lint.rules._ast_index import NodeIndex
 from sarj_python_lint.rules._fastapi import FastapiIndex
 from sarj_python_lint.rules._imports import ImportIndex
@@ -18,6 +19,7 @@ if TYPE_CHECKING:
     from pathlib import Path
 
     from sarj_python_lint.rules._copy_on_write import CopyOnWriteAnalysis
+    from sarj_python_lint.rules._resource_provenance import ResourceProvenance
     from sarj_python_lint.rules._test_provenance import TestProvenance
 
 
@@ -91,6 +93,10 @@ class PythonFileContext:
     def module_imports(self) -> ImportIndex:
         return ImportIndex.from_tree(self._valid_tree(), module_scope_only=True)
 
+    @cached_property
+    def annotation_semantics(self) -> AnnotationSemantics:
+        return AnnotationSemantics.from_imports(self._valid_tree(), self.module_imports)
+
     @cached_property
     def dynamic_namespace(self) -> bool:
         return dynamic_namespace_access(self.nodes(ast.AST), self.imports, self.parents)
@@ -117,3 +123,16 @@ class PythonFileContext:
         from sarj_python_lint.rules._copy_on_write import CopyOnWriteAnalysis  # ruff: ignore[import-outside-top-level] — share ownership analysis only when requested
 
         return CopyOnWriteAnalysis(self)
+
+    @cached_property
+    def resource_provenance(self) -> ResourceProvenance:
+        from sarj_python_lint.rules._resource_provenance import ResourceProvenance  # ruff: ignore[import-outside-top-level] -- file-owned binding facts are lazy.
+
+        # The owner caches this analysis; borrowing prevents a reference cycle.
+        return ResourceProvenance(self, borrow_context=True)
+
+    @cached_property
+    def static_resource_provenance(self) -> ResourceProvenance:
+        from sarj_python_lint.rules._resource_provenance import ResourceProvenance  # ruff: ignore[import-outside-top-level] -- keep static-namespace policy in a separate cached analysis.
+
+        return ResourceProvenance(self, require_static_namespace=True, borrow_context=True)

sarj_python_lint-1.66.0/src/sarj_python_lint/cast_access.py

@@ -0,0 +1,252 @@
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Literal
+
+from sarj_python_lint._file_context import PythonFileContext
+from sarj_python_lint.rules._namespace_access import dynamic_namespace_access
+
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+    from pathlib import Path
+
+    from sarj_python_lint.rules._resource_provenance import ResourceProvenance
+
+
+_TYPING = frozenset({"typing", "typing_extensions"})
+_GETATTR_ARITIES = frozenset({2, 3})
+_MAX_LITERAL_DEPTH = 12
+_CAST_LENGTH = len("cast")
+_COMPREHENSIONS = (ast.ListComp, ast.SetComp, ast.DictComp, ast.GeneratorExp)
+
+
+@dataclass(frozen=True, slots=True)
+class CastAccess:
+    node: ast.Call | ast.Subscript | ast.ImportFrom
+    qualified_api: str
+    kind: Literal["wildcard", "reflection"]
+
+
+def indirect_typing_cast_accesses(path: Path, source: str) -> tuple[CastAccess, ...]:
+    context = PythonFileContext(path, source)
+    if not any(marker in context.symbol_source for marker in ("*", "getattr", "__dict__", "vars", "__getattribute__")):
+        return ()
+    if context.tree is None:
+        return ()
+    accesses = [
+        CastAccess(node, f"{node.module}.cast", "wildcard")
+        for node in context.nodes(ast.ImportFrom)
+        if node.level == 0 and node.module in _TYPING and any(alias.name == "*" for alias in node.names)
+    ]
+    accesses.extend(_reflection_accesses(context))
+    return tuple(sorted(accesses, key=lambda access: (access.node.lineno, access.node.col_offset)))
+
+
+def _reflection_accesses(context: PythonFileContext) -> list[CastAccess]:
+    provenance = context.resource_provenance
+    candidates = [
+        (node, receiver)
+        for node in context.nodes(ast.Call, ast.Subscript)
+        if (receiver := _cast_receiver(node, provenance)) is not None
+    ]
+    if not candidates:
+        return []
+    receivers = {id(receiver) for _, receiver in candidates}
+    proven = [
+        (node, module)
+        for node, receiver in candidates
+        if (module := _typing_receiver(receiver, provenance, receivers)) is not None
+    ]
+    safe_reflection = {id(carrier) for node, _ in proven if (carrier := _reflection_carrier(node)) is not None}
+    namespace_hazard = dynamic_namespace_access(
+        (node for node in context.nodes(ast.AST) if id(node) not in safe_reflection), context.imports, context.parents
+    )
+    if provenance.wildcard or namespace_hazard or not provenance.builtin_namespace_untouched:
+        return []
+    return [CastAccess(node, f"{module}.cast", "reflection") for node, module in proven]
+
+
+def _cast_receiver(node: ast.Call | ast.Subscript, provenance: ResourceProvenance) -> ast.Name | None:
+    if isinstance(node, ast.Call):
+        return _call_receiver(node, provenance)
+    if not isinstance(node.ctx, ast.Load) or _static_text(node.slice) != "cast":
+        return None
+    namespace = node.value
+    if isinstance(namespace, ast.Attribute) and namespace.attr == "__dict__" and isinstance(namespace.value, ast.Name):
+        return namespace.value
+    if isinstance(namespace, ast.Call) and len(namespace.args) == 1 and _builtin_call(namespace, "vars", provenance):
+        return namespace.args[0] if isinstance(namespace.args[0], ast.Name) else None
+    return None
+
+
+def _call_receiver(node: ast.Call, provenance: ResourceProvenance) -> ast.Name | None:
+    if (
+        len(node.args) in _GETATTR_ARITIES
+        and _builtin_call(node, "getattr", provenance)
+        and _static_text(node.args[1]) == "cast"
+    ):
+        return node.args[0] if isinstance(node.args[0], ast.Name) else None
+    if (
+        isinstance(node.func, ast.Attribute)
+        and node.func.attr == "__getattribute__"
+        and len(node.args) == 1
+        and not node.keywords
+        and _static_text(node.args[0]) == "cast"
+    ):
+        return node.func.value if isinstance(node.func.value, ast.Name) else None
+    return None
+
+
+def _builtin_call(call: ast.Call, name: str, provenance: ResourceProvenance) -> bool:
+    if not isinstance(call.func, ast.Name) or call.func.id != name or call.keywords:
+        return False
+    return not _type_parameter_shadowed(name, call.func, provenance) and all(
+        name not in provenance.bindings.get(scope, {}) for scope in _lexical_scopes(call.func, provenance)
+    )
+
+
+def _lexical_scopes(node: ast.AST, provenance: ResourceProvenance) -> Iterator[ast.AST]:
+    scope = _evaluation_scope(node, provenance)
+    immediate = True
+    while scope is not None:
+        # Ordinary nested code blocks do not capture class locals.
+        if immediate or not isinstance(scope, ast.ClassDef):
+            yield scope
+        immediate = False
+        scope = _evaluation_scope(scope, provenance)
+
+
+def _evaluation_scope(node: ast.AST, provenance: ResourceProvenance) -> ast.AST | None:
+    scope = provenance.scope(node)
+    if isinstance(scope, ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef) and _owner_annotation(
+        node, scope, provenance
+    ):
+        node, scope = scope, provenance.scope(scope)
+    while isinstance(scope, _COMPREHENSIONS):
+        iterable = scope.generators[0].iter
+        if iterable is not node and not provenance.contains(iterable, node):
+            break
+        # A comprehension's first iterable is evaluated in the enclosing scope.
+        node, scope = scope, provenance.scope(scope)
+    return scope
+
+
+def _owner_annotation(
+    node: ast.AST, owner: ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef, provenance: ResourceProvenance
+) -> bool:
+    if any(parameter is node or provenance.contains(parameter, node) for parameter in owner.type_params):
+        return True
+    return isinstance(owner, ast.FunctionDef | ast.AsyncFunctionDef) and _function_annotation(node, owner, provenance)
+
+
+def _function_annotation(
+    node: ast.AST, function: ast.FunctionDef | ast.AsyncFunctionDef, provenance: ResourceProvenance
+) -> bool:
+    current = node
+    while (parent := provenance.context.parents.get(current)) is not None:
+        if (parent is function and current is function.returns) or (
+            isinstance(parent, ast.arg) and current is parent.annotation
+        ):
+            return True
+        if parent is function:
+            break
+        current = parent
+    return False
+
+
+def _type_parameter_shadowed(name: str, node: ast.AST, provenance: ResourceProvenance) -> bool:
+    current: ast.AST | None = node
+    while current is not None:
+        if (
+            isinstance(current, ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef | ast.TypeAlias)
+            and any(
+                isinstance(parameter, ast.TypeVar | ast.TypeVarTuple | ast.ParamSpec) and parameter.name == name
+                for parameter in current.type_params
+            )
+            and not _outside_parameter_scope(node, current, provenance)
+            and not _local_binding_overrides(name, node, current, provenance)
+        ):
+            return True
+        current = provenance.context.parents.get(current)
+    return False
+
+
+def _outside_parameter_scope(
+    node: ast.AST,
+    owner: ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef | ast.TypeAlias,
+    provenance: ResourceProvenance,
+) -> bool:
+    outside = [] if isinstance(owner, ast.TypeAlias) else list(owner.decorator_list)
+    if isinstance(owner, ast.FunctionDef | ast.AsyncFunctionDef):
+        outside.extend(owner.args.defaults)
+        outside.extend(value for value in owner.args.kw_defaults if value is not None)
+    # Defaults and decorators evaluate in the enclosing scope.
+    return any(value is node or provenance.contains(value, node) for value in outside)
+
+
+def _local_binding_overrides(name: str, node: ast.AST, owner: ast.AST, provenance: ResourceProvenance) -> bool:
+    for scope in _lexical_scopes(node, provenance):
+        if scope is not owner and not provenance.contains(owner, scope):
+            return False
+        if name in provenance.bindings.get(scope, {}):
+            return True
+    return False
+
+
+def _static_text(node: ast.expr, depth: int = 0) -> str | None:
+    # Evaluate only bounded, side-effect-free string syntax, never runtime code.
+    if depth > _MAX_LITERAL_DEPTH:
+        return None
+    if isinstance(node, ast.Constant) and isinstance(node.value, str):
+        return node.value if len(node.value) <= _CAST_LENGTH else None
+    if isinstance(node, ast.JoinedStr):
+        # Parsing adjacent static f-strings folds them into one Constant.
+        return _static_text(node.values[0], depth + 1) if len(node.values) == 1 else None
+    if not isinstance(node, ast.BinOp) or not isinstance(node.op, ast.Add):
+        return None
+    left, right = _static_text(node.left, depth + 1), _static_text(node.right, depth + 1)
+    if left is None or right is None:
+        return None
+    text = left + right
+    return text if len(text) <= _CAST_LENGTH else None
+
+
+def _reflection_carrier(node: ast.Call | ast.Subscript) -> ast.AST | None:
+    if isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute):
+        return node.func
+    if isinstance(node, ast.Subscript):
+        return node.value.func if isinstance(node.value, ast.Call) else node.value
+    return None
+
+
+def _typing_receiver(node: ast.Name, provenance: ResourceProvenance, receivers: set[int]) -> str | None:
+    if node.id in provenance.mutated | provenance.external_bindings:
+        return None
+    binding = _name_binding(node, provenance)
+    if not (
+        isinstance(binding, ast.alias)
+        and isinstance(provenance.context.parents.get(binding), ast.Import)
+        and binding.name in _TYPING
+    ):
+        return None
+    for read in provenance.reads.get(node.id, ()):
+        if _name_binding(read, provenance) is not binding:
+            continue
+        parent = provenance.context.parents.get(read)
+        if isinstance(parent, ast.Attribute) and parent.value is read:
+            continue
+        if id(read) in receivers:
+            continue
+        return None
+    return binding.name
+
+
+def _name_binding(node: ast.Name, provenance: ResourceProvenance) -> ast.AST | None:
+    if _type_parameter_shadowed(node.id, node, provenance):
+        return None
+    for scope in _lexical_scopes(node, provenance):
+        if bindings := provenance.bindings.get(scope, {}).get(node.id):
+            return provenance.binding(node.id, bindings[0])
+    return None

{sarj_python_lint-1.63.1 → sarj_python_lint-1.66.0}/src/sarj_python_lint/rule_base.py

@@ -20,6 +20,7 @@ from sarj_rule_contracts import (
 )
 
 from sarj_python_lint._python_target import PythonTargetFacts
+from sarj_python_lint.suppression_policy import PROTECTED_SUPPRESSION_CODES
 
 
 if TYPE_CHECKING:
@@ -43,7 +44,7 @@ _SARJ_NOQA_RE = re.compile(
 
 
 def is_suppressed(source_lines: Sequence[str], line: int, code: str) -> bool:
-    if line < 1 or line > len(source_lines):
+    if code.upper() in PROTECTED_SUPPRESSION_CODES or line < 1 or line > len(source_lines):
         return False
     text = source_lines[line - 1]
     m = _SARJ_NOQA_RE.search(text)
@@ -58,8 +59,7 @@ def is_suppressed(source_lines: Sequence[str], line: int, code: str) -> bool:
     codes_str = m.group(1)
     trailing = comment[m.end() :]
     if codes_str is None:
-        # A complete bare marker preserves the existing all-codes waiver contract.
-        return not (trailing and (not trailing[0].isspace() or trailing.lstrip().startswith(":")))
+        return False
     reason = trailing.lstrip()
     single_dash_reason = reason.startswith("-") and (codes_str[-1:].isspace() or trailing[:1].isspace())
     if reason and not reason.startswith(("--", "—", "–")) and not single_dash_reason:

{sarj_python_lint-1.63.1 → sarj_python_lint-1.66.0}/src/sarj_python_lint/rules/_annotation_semantics.py

@@ -19,7 +19,10 @@ class AnnotationSemantics:
 
     @classmethod
     def from_tree(cls, tree: ast.Module, *, module_scope_only: bool = True) -> Self:
-        imports = ImportIndex.from_tree(tree, module_scope_only=module_scope_only)
+        return cls.from_imports(tree, ImportIndex.from_tree(tree, module_scope_only=module_scope_only))
+
+    @classmethod
+    def from_imports(cls, tree: ast.Module, imports: ImportIndex) -> Self:
         candidates: dict[str, ast.expr] = {}
         ambiguous: set[str] = set()
         for statement in tree.body:

{sarj_python_lint-1.63.1 → sarj_python_lint-1.66.0}/src/sarj_python_lint/rules/_copy_on_write.py

@@ -110,9 +110,7 @@ class _Models:
     def validation_owner(self, unit: SourceUnit) -> _ValidationOwner:
         if unit.path not in self._validation_owners:
             context = PythonFileContext(unit.path, unit.source, self._validation_session)
-            self._validation_owners[unit.path] = _ValidationOwner(
-                context, ResourceProvenance(context, require_static_namespace=True)
-            )
+            self._validation_owners[unit.path] = _ValidationOwner(context, context.static_resource_provenance)
         return self._validation_owners[unit.path]
 
     def annotations(self, unit: SourceUnit) -> AnnotationSemantics:
@@ -378,7 +376,7 @@ class CopyOnWriteAnalysis:
 
     @cached_property
     def _validator_provider(self) -> ResourceProvenance:
-        return ResourceProvenance(self.context, require_static_namespace=True)
+        return self.context.static_resource_provenance
 
     def _function(self, function: _Function) -> None:
         parameters = [*function.args.posonlyargs, *function.args.args, *function.args.kwonlyargs]

{sarj_python_lint-1.63.1 → sarj_python_lint-1.66.0}/src/sarj_python_lint/rules/_data_union_discriminator.py

@@ -72,6 +72,7 @@ def data_union_diagnostics(context: PythonFileContext, code: str) -> list[Diagno
 class _DataUnions:
     def __init__(self, context: PythonFileContext, tree: ast.Module) -> None:
         self.context = context
+        # This analysis refines mutation ownership; keep its provenance private.
         self.provenance = ResourceProvenance(context, require_static_namespace=True)
         self.provenance.mutated = _scoped_module_mutations(self.provenance, tree)
         bindings = self.provenance.bindings.get(tree, {})

{sarj_python_lint-1.63.1 → sarj_python_lint-1.66.0}/src/sarj_python_lint/rules/_pydantic_field_contract.py

@@ -13,11 +13,11 @@ from sarj_python_lint.json_boundary import is_object_mapping
 from sarj_python_lint.rules._first_party import distribution_root
 from sarj_python_lint.rules._namespace_access import dynamic_namespace_access
 from sarj_python_lint.rules._native_namespace_capability import native_namespace_capability_escapes
-from sarj_python_lint.rules._resource_provenance import ResourceProvenance
 
 
 if TYPE_CHECKING:
     from sarj_python_lint._file_context import PythonFileContext
+    from sarj_python_lint.rules._resource_provenance import ResourceProvenance
 
 
 MODEL_SOURCES = frozenset({"pydantic", "pydantic.main"})
@@ -43,7 +43,7 @@ def direct_models(context: PythonFileContext, *, methods: bool = False) -> tuple
         or dynamic_namespace_access(context.nodes(ast.AST), context.imports, context.parents)
     ):
         return ()
-    provenance = ResourceProvenance(context, require_static_namespace=True)
+    provenance = context.static_resource_provenance
     return tuple(
         node
         for node in tree.body

{sarj_python_lint-1.63.1 → sarj_python_lint-1.66.0}/src/sarj_python_lint/rules/_registry.py

@@ -34,6 +34,7 @@ from sarj_python_lint.rules.no_analytical_aggregation_in_postgres_store import (
 from sarj_python_lint.rules.no_any_mapping_types import NoAnyMappingTypes
 from sarj_python_lint.rules.no_async_function_cache import NoAsyncFunctionCache
 from sarj_python_lint.rules.no_before_validator_input_mutation import NoBeforeValidatorInputMutation
+from sarj_python_lint.rules.no_blanket_suppression import NoBlanketSuppression
 from sarj_python_lint.rules.no_broad_keyword_capture import NoBroadKeywordCapture
 from sarj_python_lint.rules.no_comment_cruft import NoCommentCruft
 from sarj_python_lint.rules.no_conftest_test_module_import import NoConftestTestModuleImport
@@ -329,6 +330,7 @@ REGISTRY: Mapping[str, type[Rule]] = MappingProxyType(
         RequirePydanticForExternalJson.id: RequirePydanticForExternalJson,
         RequirePydanticForMappingShape.id: RequirePydanticForMappingShape,
         NoDualShapeModelFieldReader.id: NoDualShapeModelFieldReader,
+        NoBlanketSuppression.id: NoBlanketSuppression,
         PreferModuleLevelConstant.id: PreferModuleLevelConstant,
         PreferImmutableModuleConstant.id: PreferImmutableModuleConstant,
         PreferInjectedDependencyOverMonkeypatch.id: PreferInjectedDependencyOverMonkeypatch,