sarj-python-lint 1.85.0__tar.gz → 1.88.1__tar.gz

{sarj_python_lint-1.85.0 → sarj_python_lint-1.88.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 1.85.0
+Version: 1.88.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/
@@ -19,7 +19,7 @@ Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: >=3.14
 Requires-Dist: packaging==26.3
 Requires-Dist: ruff>=0.17.2
-Requires-Dist: sarj-rule-contracts==0.4.2
+Requires-Dist: sarj-rule-contracts==0.5.0
 Requires-Dist: sqlglot==30.24.0
 Requires-Dist: typer==0.27.3
 Description-Content-Type: text/markdown

{sarj_python_lint-1.85.0 → sarj_python_lint-1.88.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sarj-python-lint"
-version = "1.85.0"
+version = "1.88.1"
 description = "Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults"
 readme = "README.md"
 authors = [{ name = "sarj-ai" }]
@@ -15,7 +15,7 @@ classifiers = [
   "Programming Language :: Python :: 3.14",
   "Topic :: Software Development :: Quality Assurance",
 ]
-dependencies = ["sarj-rule-contracts==0.4.2", "packaging==26.3", "ruff>=0.17.2", "sqlglot==30.24.0", "typer==0.27.3"]
+dependencies = ["sarj-rule-contracts==0.5.0", "packaging==26.3", "ruff>=0.17.2", "sqlglot==30.24.0", "typer==0.27.3"]
 
 [project.scripts]
 sarj-python-lint = "sarj_python_lint.__main__:main"

{sarj_python_lint-1.85.0 → sarj_python_lint-1.88.1}/src/sarj_python_lint/__main__.py

@@ -18,6 +18,7 @@ from sarj_python_lint import __version__
 from sarj_python_lint._analysis_session import AnalysisSession
 from sarj_python_lint._file_context import PythonFileContext
 from sarj_python_lint._filesystem import atomic_write_text
+from sarj_python_lint._prepared_sources import PreparedSourceInputs
 from sarj_python_lint._source import read_python_source
 from sarj_python_lint.json_boundary import is_object_mapping, parse_json
 from sarj_python_lint.rule_base import Diagnostic, ProjectRule, Rule, Severity, is_suppressed
@@ -30,6 +31,8 @@ from sarj_python_lint.suppression_policy import PROTECTED_SUPPRESSION_CODES
 if TYPE_CHECKING:
     from collections.abc import Sequence
 
+    from sarj_rule_contracts import SourceCatalog
+
 
 SKIP_DIR_NAMES = frozenset(
     {
@@ -101,7 +104,9 @@ def _canonical_rule_ids(rule_names: Sequence[str]) -> list[RuleId]:
     return list(dict.fromkeys(RuleId(name if name in REGISTRY else aliases.get(name, name)) for name in rule_names))
 
 
-def _check(rule_names: Sequence[str], paths: list[Path], *, jobs: int = 1) -> list[Diagnostic]:
+def _check(
+    rule_names: Sequence[str], paths: list[Path], *, jobs: int = 1, sources: SourceCatalog | None = None
+) -> list[Diagnostic]:
     rule_ids = _canonical_rule_ids(rule_names)
     unknown = [rid for rid in rule_ids if rid not in REGISTRY]
     if unknown:
@@ -109,30 +114,81 @@ def _check(rule_names: Sequence[str], paths: list[Path], *, jobs: int = 1) -> li
         sys.stderr.write(f"available: {', '.join(sorted(REGISTRY))}\n")
         raise SystemExit(2)
     rules = [REGISTRY[rid]() for rid in rule_ids]
-    session = AnalysisSession()
+    source_inputs = None if sources is None else PreparedSourceInputs(sources)
+    session = AnalysisSession() if source_inputs is None else AnalysisSession(source_inputs=source_inputs)
     for rule in rules:
         rule.prepare_session(session)
     clear_path_caches()
     expanded = expand_paths(paths)
-    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)
-        session.project = indexes
-        for rule in project_rules:
-            rule.prepare(indexes)
-    if jobs > 1 and len(loaded) > 1:
-        from sarj_python_lint._parallel import check_parallel  # ruff: ignore[import-outside-top-level] -- serial API users do not need multiprocessing.
-
-        parallel = check_parallel([type(rule) for rule in rules], loaded, session.project, jobs=jobs)
-        if parallel is not None:
-            return parallel
+    loaded = (
+        _load_python_sources(expanded, sources)
+        if source_inputs is None
+        else _load_python_sources(expanded, sources, source_inputs=source_inputs)
+    )
+    _prepare_project(rules, expanded, loaded, session, source_inputs=source_inputs)
+    parallel = _parallel_diagnostics(rules, loaded, session, jobs=jobs, source_inputs=source_inputs)
+    if parallel is not None:
+        return parallel
     diags: list[Diagnostic] = []
     for p, source in loaded.items():
         diags.extend(check_source(rules, p, source, session=session))
     return diags
 
 
+def _load_python_sources(
+    paths: Sequence[Path], sources: SourceCatalog | None, *, source_inputs: PreparedSourceInputs | None = None
+) -> dict[Path, str]:
+    if sources is None:
+        return {path: read_python_source(path) for path in paths}
+    loaded = {path: read_python_source(path, sources=sources) for path in paths}
+    if source_inputs is not None:
+        for path in loaded:
+            snapshot = sources.get(path)
+            if snapshot is not None:
+                source_inputs.remember_selected(path, snapshot)
+    return loaded
+
+
+def _prepare_project(
+    rules: list[Rule],
+    expanded: list[Path],
+    loaded: dict[Path, str],
+    session: AnalysisSession,
+    *,
+    source_inputs: PreparedSourceInputs | None,
+) -> None:
+    project_rules = [rule for rule in rules if isinstance(rule, ProjectRule)]
+    if not project_rules:
+        return
+    indexes = (
+        ProjectIndexSet.build(expanded, loaded, facts=session.first_party)
+        if source_inputs is None
+        else ProjectIndexSet.build(expanded, loaded, facts=session.first_party, source_inputs=source_inputs)
+    )
+    session.project = indexes
+    for rule in project_rules:
+        rule.prepare(indexes)
+
+
+def _parallel_diagnostics(
+    rules: list[Rule],
+    loaded: dict[Path, str],
+    session: AnalysisSession,
+    *,
+    jobs: int,
+    source_inputs: PreparedSourceInputs | None,
+) -> list[Diagnostic] | None:
+    if jobs <= 1 or len(loaded) <= 1:
+        return None
+    from sarj_python_lint._parallel import check_parallel  # ruff: ignore[import-outside-top-level] -- serial API users do not need multiprocessing.
+
+    if source_inputs is None:
+        return check_parallel([type(rule) for rule in rules], loaded, session.project, jobs=jobs)
+    return check_parallel(
+        [type(rule) for rule in rules], loaded, session.project, jobs=jobs, source_inputs=source_inputs
+    )
+
+
 def check_source(
     rules: list[Rule], p: Path, source: str, *, session: AnalysisSession | None = None
 ) -> list[Diagnostic]:
@@ -156,11 +212,12 @@ def analyze(
     baseline: Path | None = None,
     root: Path | None = None,
     jobs: int = 1,
+    sources: SourceCatalog | None = None,
 ) -> list[Diagnostic]:
     if jobs < 1:
         msg = "jobs must be at least 1"
         raise ValueError(msg)
-    diagnostics = _check(rule_ids, paths, jobs=jobs)
+    diagnostics = _check(rule_ids, paths, jobs=jobs, sources=sources)
     return diagnostics if baseline is None else _apply_baseline(diagnostics, _read_baseline(baseline), root=root)
 
 

{sarj_python_lint-1.85.0 → sarj_python_lint-1.88.1}/src/sarj_python_lint/_analysis_session.py

@@ -9,14 +9,18 @@ from sarj_python_lint.rules._nominal_project import NominalProjectFacts
 
 
 if TYPE_CHECKING:
+    from sarj_python_lint._prepared_sources import PreparedSourceInputs
     from sarj_python_lint.rules._project_index import ProjectIndexSet
 
 
 @final
 class AnalysisSession:
-    def __init__(self) -> None:
+    def __init__(self, *, source_inputs: PreparedSourceInputs | None = None) -> None:
         self.project: ProjectIndexSet | None = None
+        self.source_inputs = source_inputs
         self.first_party = FirstPartyFacts()
-        self.local_source = LocalSourceFacts()
+        self.local_source = (
+            LocalSourceFacts() if source_inputs is None else LocalSourceFacts(source_inputs=source_inputs)
+        )
         self.python_target = PythonTargetFacts()
         self.nominal_project = NominalProjectFacts()

{sarj_python_lint-1.85.0 → sarj_python_lint-1.88.1}/src/sarj_python_lint/_parallel.py

@@ -7,6 +7,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 from sarj_python_lint._analysis_session import AnalysisSession
+from sarj_python_lint._prepared_sources import NeedsSerialSourceError, PreparedSourceInputs
 from sarj_python_lint.rule_base import Diagnostic, ProjectRule, Rule
 from sarj_python_lint.rules._local_source import LOCAL_SOURCE_CACHE_LIMIT
 from sarj_python_lint.rules._paths import clear_path_caches
@@ -14,6 +15,7 @@ from sarj_python_lint.rules._project_index import ProjectIndexSet
 
 
 if TYPE_CHECKING:
+    from sarj_python_lint._prepared_sources import PreparedSourceSnapshot
     from sarj_python_lint.rules._project_index import ProjectSourceSnapshot
 
 
@@ -26,6 +28,7 @@ class _WorkerState:
     session: AnalysisSession
     resolutions: frozenset[_ResolutionKey] = frozenset()
     modules: frozenset[Path] = frozenset()
+    needs_serial: bool = False
 
 
 @dataclass(frozen=True, slots=True)
@@ -33,70 +36,128 @@ class _FileResult:
     diagnostics: list[Diagnostic]
     resolutions: frozenset[_ResolutionKey]
     modules: frozenset[Path]
+    needs_serial: bool = False
 
 
 _state: _WorkerState | None = None
 
 
-def _initialize(rule_types: list[type[Rule]], snapshot: ProjectSourceSnapshot | None) -> None:
+def _initialize(
+    rule_types: list[type[Rule]],
+    snapshot: ProjectSourceSnapshot | None,
+    source_snapshot: PreparedSourceSnapshot | None = None,
+) -> None:
     global _state  # ruff: ignore[global-statement] -- each spawned process owns one initialized session.
     rules = [rule_type() for rule_type in rule_types]
-    session = AnalysisSession()
-    for rule in rules:
-        rule.prepare_session(session)
+    source_inputs = None if source_snapshot is None else PreparedSourceInputs.from_source_snapshot(source_snapshot)
+    session = AnalysisSession() if source_inputs is None else AnalysisSession(source_inputs=source_inputs)
+    _state = _WorkerState(rules, session)
+    try:
+        _prepare_worker(_state, snapshot, source_inputs=source_inputs)
+    except NeedsSerialSourceError:
+        _state.needs_serial = True
+
+
+def _prepare_worker(
+    state: _WorkerState, snapshot: ProjectSourceSnapshot | None, *, source_inputs: PreparedSourceInputs | None
+) -> None:
+    for rule in state.rules:
+        rule.prepare_session(state.session)
     clear_path_caches()
-    project = ProjectIndexSet.from_source_snapshot(snapshot) if snapshot is not None else None
-    session.project = project
-    for rule in rules:
+    project = None
+    if snapshot is not None:
+        project = (
+            ProjectIndexSet.from_source_snapshot(snapshot)
+            if source_inputs is None
+            else ProjectIndexSet.from_source_snapshot(snapshot, sealed=True)
+        )
+    state.session.project = project
+    for rule in state.rules:
         if isinstance(rule, ProjectRule) and project is not None:
             rule.prepare(project)
-    _state = _WorkerState(rules, session)
 
 
-def _check_file(item: tuple[Path, str]) -> _FileResult:
+def _check_file(item: tuple[Path, str | None]) -> _FileResult:
     from sarj_python_lint.__main__ import check_source  # ruff: ignore[import-outside-top-level] -- keep spawn targets in an importable module.
 
     if _state is None:
         msg = "Python analysis worker was not initialized"
         raise RuntimeError(msg)
     path, source = item
-    diagnostics = check_source(_state.rules, path, source, session=_state.session)
+    if _state.needs_serial:
+        return _FileResult([], frozenset(), frozenset(), needs_serial=True)
+    try:
+        if source is None:
+            source = _selected_worker_source(_state.session, path)
+        diagnostics = check_source(_state.rules, path, source, session=_state.session)
+    except NeedsSerialSourceError:
+        _state.needs_serial = True
+        return _FileResult([], frozenset(), frozenset(), needs_serial=True)
     keys = _state.session.local_source.cache_keys()
     result = _FileResult(diagnostics, keys.resolutions - _state.resolutions, keys.modules - _state.modules)
     _state.resolutions, _state.modules = keys.resolutions, keys.modules
     return result
 
 
+def _selected_worker_source(session: AnalysisSession, path: Path) -> str:
+    if session.source_inputs is None:
+        raise NeedsSerialSourceError
+    return session.source_inputs.selected_text(path)
+
+
 def check_parallel(
     rule_types: list[type[Rule]],
     loaded: dict[Path, str],
     project: ProjectIndexSet | None,
     *,
     jobs: int,
+    source_inputs: PreparedSourceInputs | None = None,
 ) -> list[Diagnostic] | None:
     # The untouched parent rules/session remain the serial fallback. Workers
     # receive the same complete project snapshot and selected source strings.
+    source_snapshot = None if source_inputs is None else source_inputs.source_snapshot()
+    if source_snapshot is not None and source_snapshot.eligible_raw_count >= LOCAL_SOURCE_CACHE_LIMIT:
+        return None
     workers = min(jobs, 2, len(loaded))
     pool = ProcessPoolExecutor(
         max_workers=workers,
         mp_context=multiprocessing.get_context("spawn"),
         initializer=_initialize,
-        initargs=(rule_types, project.source_snapshot() if project is not None else None),
+        initargs=(rule_types, project.source_snapshot() if project is not None else None, source_snapshot),
     )
     diagnostics: list[Diagnostic] = []
     resolutions: set[_ResolutionKey] = set()
     modules: set[Path] = set()
+    needs_serial = False
     try:
         # Keep workers busy while an earlier file delays ordered results.
-        for result in pool.map(_check_file, loaded.items(), chunksize=1, buffersize=workers * 4):
+        items = (
+            (
+                path,
+                None
+                if source_inputs is not None
+                and (captured := source_inputs.selected_capture(path)) is not None
+                and captured.snapshot is not None
+                else source,
+            )
+            for path, source in loaded.items()
+        )
+        for result in pool.map(_check_file, items, chunksize=1, buffersize=workers * 4):
+            if result.needs_serial:
+                # Drain the actual worker results so another initializer/file
+                # failure cannot be disguised as a clean serial replay.
+                needs_serial = True
+                continue
             resolutions.update(result.resolutions)
             modules.update(result.modules)
             # A worker cannot hit either order-dependent limit when the whole
             # union stays strictly below it. At the boundary, discard all output.
-            if len(resolutions) >= LOCAL_SOURCE_CACHE_LIMIT or len(modules) >= LOCAL_SOURCE_CACHE_LIMIT:
+            if not needs_serial and (
+                len(resolutions) >= LOCAL_SOURCE_CACHE_LIMIT or len(modules) >= LOCAL_SOURCE_CACHE_LIMIT
+            ):
                 return None
             diagnostics.extend(result.diagnostics)
-        return diagnostics
+        return None if needs_serial else diagnostics
     finally:
         # Bound queued work and reap before fallback/error return. Running file
         # checks finish normally; group cancellation belongs to the supervisor.

sarj_python_lint-1.88.1/src/sarj_python_lint/_prepared_sources.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING, final
+
+from sarj_rule_contracts import SourceSnapshot
+
+from sarj_python_lint._source import decode_python_source
+
+
+if TYPE_CHECKING:
+    from sarj_rule_contracts import SourceCatalog
+
+
+LOCAL_MODULE_MAX_BYTES = 256_000
+type ResolutionKey = tuple[Path, str | None, int]
+
+
+# The sealed worker needs an observation available only to the parent.
+class NeedsSerialSourceError(Exception):
+    pass
+
+
+@dataclass(frozen=True, slots=True)
+class CapturedSource:
+    # Larger project units keep their text and actual byte size on the wire;
+    # local analysis must decline them without a second full raw body.
+    path: Path
+    raw_size: int
+    snapshot: SourceSnapshot | None = field(default=None, repr=False)
+
+    @classmethod
+    def from_snapshot(cls, snapshot: SourceSnapshot) -> CapturedSource:
+        size = len(snapshot.raw)
+        return cls(snapshot.path, size, snapshot if size <= LOCAL_MODULE_MAX_BYTES else None)
+
+
+@dataclass(frozen=True, slots=True)
+class PreparedSourceSnapshot:
+    entries: tuple[tuple[Path, CapturedSource], ...]
+    selected: tuple[tuple[Path, CapturedSource], ...]
+    conflicts: frozenset[Path]
+    resolutions: tuple[tuple[ResolutionKey, Path | None], ...]
+    failed_modules: frozenset[Path]
+
+    @property
+    def eligible_raw_count(self) -> int:
+        return len({id(entry.snapshot) for _, entry in (*self.entries, *self.selected) if entry.snapshot is not None})
+
+    @property
+    def raw_bytes(self) -> int:
+        snapshots = {
+            id(entry.snapshot): entry.snapshot
+            for _, entry in (*self.entries, *self.selected)
+            if entry.snapshot is not None
+        }
+        return sum(len(snapshot.raw) for snapshot in snapshots.values())
+
+
+@final
+class PreparedSourceInputs:
+    def __init__(self, catalog: SourceCatalog | None = None, *, sealed: bool = False) -> None:
+        self._catalog = catalog
+        self.sealed = sealed
+        self._entries: dict[Path, CapturedSource] = {}
+        self._selected: dict[Path, CapturedSource] = {}
+        self._conflicts: set[Path] = set()
+        self._resolutions: dict[ResolutionKey, Path | None] = {}
+        self._failed_modules: set[Path] = set()
+
+    def remember_selected(self, path: Path, snapshot: SourceSnapshot) -> None:
+        captured = CapturedSource.from_snapshot(snapshot)
+        self._selected[path] = captured
+        self.remember(path, captured)
+
+    def selected_capture(self, path: Path) -> CapturedSource | None:
+        return self._selected.get(path)
+
+    def selected_text(self, path: Path) -> str:
+        captured = self._selected.get(path)
+        if captured is None or captured.snapshot is None:
+            raise NeedsSerialSourceError
+        try:
+            return decode_python_source(captured.snapshot)
+        except UnicodeError, SyntaxError:
+            raise NeedsSerialSourceError from None
+
+    def remember(self, path: Path, captured: CapturedSource) -> None:
+        if self.sealed:
+            raise NeedsSerialSourceError
+        previous = self._entries.get(path)
+        if previous is None:
+            self._entries[path] = captured
+        elif previous is not captured and not self._same_bytes(previous, captured):
+            self._conflicts.add(path)
+
+    def _same_bytes(self, first: CapturedSource, second: CapturedSource) -> bool:
+        left = self._body(first)
+        right = self._body(second)
+        return left is not None and right is not None and left.raw == right.raw
+
+    def _body(self, captured: CapturedSource) -> SourceSnapshot | None:
+        if captured.snapshot is not None:
+            return captured.snapshot
+        return None if self._catalog is None else self._catalog.get(captured.path)
+
+    def associate_selected(self, original: Path, prepared: Path) -> CapturedSource | None:
+        captured = self._selected.get(original)
+        if captured is not None:
+            self.remember(prepared, captured)
+        return captured
+
+    def project_snapshot(self, path: Path) -> SourceSnapshot | None:
+        if path in self._conflicts:
+            return None
+        captured = self._entries.get(path)
+        return None if captured is None else self._body(captured)
+
+    def module_snapshot(self, path: Path) -> SourceSnapshot | None:
+        if path not in self._conflicts:
+            captured = self._entries.get(path)
+            if captured is not None:
+                if captured.raw_size > LOCAL_MODULE_MAX_BYTES:
+                    return None
+                if captured.snapshot is not None:
+                    return captured.snapshot
+            if path in self._failed_modules:
+                return None
+        if self.sealed:
+            raise NeedsSerialSourceError
+        # Unknown/conflicting byte views retain the parent's legacy bounded read.
+        with path.open("rb") as stream:
+            raw = stream.read(LOCAL_MODULE_MAX_BYTES + 1)
+        if len(raw) > LOCAL_MODULE_MAX_BYTES:
+            return None
+        return SourceSnapshot(path, raw)
+
+    def remember_module(self, path: Path, snapshot: SourceSnapshot) -> None:
+        # Called only after the local decoder and parser have admitted a module.
+        if not self.sealed and path not in self._conflicts:
+            self.remember(path, CapturedSource.from_snapshot(snapshot))
+
+    def record_failure(self, path: Path) -> None:
+        if not self.sealed and path not in self._entries and path not in self._conflicts:
+            self._failed_modules.add(path)
+
+    def resolution(self, key: ResolutionKey) -> Path | None:
+        if key not in self._resolutions:
+            raise NeedsSerialSourceError
+        return self._resolutions[key]
+
+    def record_resolution(self, key: ResolutionKey, result: Path | None) -> None:
+        if self.sealed:
+            raise NeedsSerialSourceError
+        self._resolutions[key] = result
+
+    def source_snapshot(self) -> PreparedSourceSnapshot:
+        return PreparedSourceSnapshot(
+            tuple(self._entries.items()),
+            tuple(self._selected.items()),
+            frozenset(self._conflicts),
+            tuple(self._resolutions.items()),
+            frozenset(self._failed_modules),
+        )
+
+    @classmethod
+    def from_source_snapshot(cls, snapshot: PreparedSourceSnapshot) -> PreparedSourceInputs:
+        inputs = cls(sealed=True)
+        inputs._entries = dict(snapshot.entries)
+        inputs._selected = dict(snapshot.selected)
+        inputs._conflicts = set(snapshot.conflicts)
+        inputs._resolutions = dict(snapshot.resolutions)
+        inputs._failed_modules = set(snapshot.failed_modules)
+        return inputs

{sarj_python_lint-1.85.0 → sarj_python_lint-1.88.1}/src/sarj_python_lint/_source.py

@@ -6,18 +6,26 @@ import tokenize
 from typing import TYPE_CHECKING
 import unicodedata
 
+from sarj_rule_contracts import NewlinePolicy, SourceSnapshot
+
 
 if TYPE_CHECKING:
     from pathlib import Path
 
+    from sarj_rule_contracts import SourceCatalog
+
 
 def python_source_encoding(data: bytes) -> str:
     return tokenize.detect_encoding(BytesIO(data).readline)[0]
 
 
-def read_python_source(path: Path) -> str:
-    with tokenize.open(path) as stream:
-        return stream.read()
+def read_python_source(path: Path, *, sources: SourceCatalog | None = None) -> str:
+    snapshot = SourceSnapshot.read(path) if sources is None else sources.capture(path)
+    return decode_python_source(snapshot)
+
+
+def decode_python_source(snapshot: SourceSnapshot) -> str:
+    return snapshot.decode(python_source_encoding(snapshot.raw), newlines=NewlinePolicy.UNIVERSAL).text
 
 
 def python_source_lines(source: str) -> list[str]:

{sarj_python_lint-1.85.0 → sarj_python_lint-1.88.1}/src/sarj_python_lint/benchmark.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from dataclasses import asdict, dataclass
+from dataclasses import asdict, dataclass, field
 import hashlib
 import json
 from os.path import commonpath
@@ -8,7 +8,7 @@ from pathlib import Path
 from statistics import median
 import sys
 from time import perf_counter
-from typing import TYPE_CHECKING, Annotated
+from typing import TYPE_CHECKING, Annotated, Literal
 
 from sarj_rule_contracts import RuleId
 import typer
@@ -21,12 +21,21 @@ if TYPE_CHECKING:
     from collections.abc import Sequence
 
 
+type MemoryScope = Literal["process-lifetime-self", "unsupported"]
+
+
 @dataclass(frozen=True, slots=True)
 class BenchmarkSample:
     seconds: float
     diagnostics: int
     diagnostic_digest: str
     peak_memory_bytes: int | None
+    memory_scope: MemoryScope = field(init=False)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self, "memory_scope", "unsupported" if self.peak_memory_bytes is None else "process-lifetime-self"
+        )
 
 
 @dataclass(frozen=True, slots=True)
@@ -40,6 +49,8 @@ class BenchmarkReport:
 
 
 def peak_memory_bytes() -> int | None:
+    if sys.platform not in {"linux", "darwin"}:
+        return None
     try:
         import resource  # ruff: ignore[import-outside-top-level] — optional Unix-only memory instrumentation.
     except ImportError:
@@ -98,7 +109,8 @@ def measure(
                 ).encode()
             )
             digest.update(b"\n")
-        samples.append(BenchmarkSample(elapsed, len(diagnostics), digest.hexdigest(), peak_memory_bytes()))
+        peak = peak_memory_bytes()
+        samples.append(BenchmarkSample(elapsed, len(diagnostics), digest.hexdigest(), peak))
     if len({sample.diagnostic_digest for sample in samples}) != 1:
         msg = "diagnostics changed between benchmark repetitions"
         raise RuntimeError(msg)

{sarj_python_lint-1.85.0 → sarj_python_lint-1.88.1}/src/sarj_python_lint/rule_base.py

@@ -10,6 +10,7 @@ from typing import TYPE_CHECKING, ClassVar, Final
 
 from sarj_rule_contracts import (
     AutofixPolicy as AutofixPolicy,
+    DiagnosticSeverity as DiagnosticSeverity,
     ExampleFile as ExampleFile,
     ExampleOutcome as ExampleOutcome,
     NativeRuleSpec as NativeRuleSpec,
@@ -17,6 +18,7 @@ from sarj_rule_contracts import (
     RuleDocumentation as RuleDocumentation,
     RuleExample as RuleExample,
     Severity as Severity,
+    diagnostic_severity,
 )
 
 from sarj_python_lint._python_target import PythonTargetFacts
@@ -100,10 +102,13 @@ class Diagnostic:
     col: int
     code: str
     message: str
-    severity: Severity = Severity.ERROR
+    severity: DiagnosticSeverity = Severity.ERROR
     column_encoding: ColumnEncoding = ColumnEncoding.UTF8_BYTES
     fixes: tuple[Fix, ...] = ()
 
+    def __post_init__(self) -> None:
+        diagnostic_severity(self.severity)
+
     def format(self) -> str:
         label = "warning: " if self.severity is Severity.WARNING else ""
         return f"{self.path}:{self.line}:{self.col}: {self.code} {label}{self.message}"