sarj-python-lint 1.67.0__tar.gz → 1.69.0__tar.gz

{sarj_python_lint-1.67.0 → sarj_python_lint-1.69.0}/PKG-INFO

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

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

{sarj_python_lint-1.67.0 → sarj_python_lint-1.69.0}/src/sarj_python_lint/__main__.py

@@ -96,7 +96,7 @@ def _canonical_rule_ids(rule_ids: list[str]) -> list[str]:
     return list(dict.fromkeys(rid if rid in REGISTRY else aliases.get(rid, rid) for rid in rule_ids))
 
 
-def _check(rule_ids: list[str], paths: list[Path]) -> list[Diagnostic]:
+def _check(rule_ids: list[str], paths: list[Path], *, jobs: int = 1) -> list[Diagnostic]:
     rule_ids = _canonical_rule_ids(rule_ids)
     unknown = [rid for rid in rule_ids if rid not in REGISTRY]
     if unknown:
@@ -116,6 +116,12 @@ def _check(rule_ids: list[str], paths: list[Path]) -> list[Diagnostic]:
         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
     diags: list[Diagnostic] = []
     for p, source in loaded.items():
         diags.extend(check_source(rules, p, source, session=session))
@@ -144,8 +150,12 @@ def analyze(
     *,
     baseline: Path | None = None,
     root: Path | None = None,
+    jobs: int = 1,
 ) -> list[Diagnostic]:
-    diagnostics = _check(rule_ids, paths)
+    if jobs < 1:
+        msg = "jobs must be at least 1"
+        raise ValueError(msg)
+    diagnostics = _check(rule_ids, paths, jobs=jobs)
     return diagnostics if baseline is None else _apply_baseline(diagnostics, _read_baseline(baseline), root=root)
 
 
@@ -481,9 +491,11 @@ def _apply_baseline(
     return out
 
 
-def _run_check(rule: list[str], files: list[Path], baseline: Path | None, update_baseline: Path | None) -> int:
+def _run_check(
+    rule: list[str], files: list[Path], baseline: Path | None, update_baseline: Path | None, *, jobs: int = 1
+) -> int:
     try:
-        diags = analyze(rule, files)
+        diags = analyze(rule, files, jobs=jobs)
     except (OSError, ValueError, SyntaxError) as exc:
         sys.stderr.write(f"error: {exc}\n")
         return 2
@@ -554,14 +566,16 @@ def _check_command(
     context: typer.Context,
     files: Annotated[list[Path], typer.Argument()],
     rule: Annotated[list[str], typer.Option("--rule", help="Rule ID (repeat for multiple).")],
+    *,
     baseline: Annotated[
         Path | None, typer.Option(help="Per-file shrink-only baseline JSON: {path: {CODE: count}}.")
     ] = None,
     update_baseline: Annotated[
         Path | None, typer.Option(help="Write current per-file diagnostic counts to JSON and exit 0.")
     ] = None,
+    jobs: Annotated[int, typer.Option(min=1, help="Analysis worker budget (up to 2); default is serial.")] = 1,
 ) -> None:
-    context.ensure_object(_Result).code = _run_check(rule, files, baseline, update_baseline)
+    context.ensure_object(_Result).code = _run_check(rule, files, baseline, update_baseline, jobs=jobs)
 
 
 def main(argv: list[str] | None = None) -> int:

sarj_python_lint-1.69.0/src/sarj_python_lint/_parallel.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from concurrent.futures import ProcessPoolExecutor
+from dataclasses import dataclass
+import multiprocessing
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from sarj_python_lint._analysis_session import AnalysisSession
+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
+from sarj_python_lint.rules._project_index import ProjectIndexSet
+
+
+if TYPE_CHECKING:
+    from sarj_python_lint.rules._project_index import ProjectSourceSnapshot
+
+
+type _ResolutionKey = tuple[Path, str | None, int]
+
+
+@dataclass
+class _WorkerState:
+    rules: list[Rule]
+    session: AnalysisSession
+    resolutions: frozenset[_ResolutionKey] = frozenset()
+    modules: frozenset[Path] = frozenset()
+
+
+@dataclass(frozen=True, slots=True)
+class _FileResult:
+    diagnostics: list[Diagnostic]
+    resolutions: frozenset[_ResolutionKey]
+    modules: frozenset[Path]
+
+
+_state: _WorkerState | None = None
+
+
+def _initialize(rule_types: list[type[Rule]], snapshot: ProjectSourceSnapshot | 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)
+    clear_path_caches()
+    project = ProjectIndexSet.from_source_snapshot(snapshot) if snapshot is not None else None
+    session.project = project
+    for rule in 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:
+    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)
+    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 check_parallel(
+    rule_types: list[type[Rule]],
+    loaded: dict[Path, str],
+    project: ProjectIndexSet | None,
+    *,
+    jobs: int,
+) -> list[Diagnostic] | None:
+    # The untouched parent rules/session remain the serial fallback. Workers
+    # receive the same complete project snapshot and selected source strings.
+    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),
+    )
+    diagnostics: list[Diagnostic] = []
+    resolutions: set[_ResolutionKey] = set()
+    modules: set[Path] = set()
+    try:
+        for result in pool.map(_check_file, loaded.items(), chunksize=1, buffersize=workers):
+            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:
+                return None
+            diagnostics.extend(result.diagnostics)
+        return diagnostics
+    finally:
+        # Bound queued work and reap before fallback/error return. Running file
+        # checks finish normally; group cancellation belongs to the supervisor.
+        pool.shutdown(wait=True, cancel_futures=True)

sarj_python_lint-1.69.0/src/sarj_python_lint/rules/_declared_contracts.py

@@ -0,0 +1,243 @@
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from sarj_python_lint.rules._annotation_semantics import AnnotationSemantics
+from sarj_python_lint.rules._imports import ImportIndex
+from sarj_python_lint.rules._project_index import ProjectIndexSet, SourceUnit, SymbolRef
+
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from sarj_python_lint._file_context import PythonFileContext
+
+
+MODEL_BASES = frozenset({"pydantic.BaseModel", "pydantic.main.BaseModel"})
+SETTINGS_BASES = frozenset({"pydantic_settings.BaseSettings", "pydantic_settings.main.BaseSettings"})
+_MAX_DEPTH = 8
+_TYPING_SOURCES = frozenset({"typing", "typing_extensions"})
+
+
+@dataclass(frozen=True)
+class DeclaredClass:
+    unit: SourceUnit
+    declaration: ast.ClassDef
+
+
+def _class_metadata_annotation(annotation: ast.expr, semantics: AnnotationSemantics) -> bool:
+    pending = [annotation]
+    seen: set[str] = set()
+    while pending:
+        node = semantics.parse(pending.pop())
+        if node is None:
+            return True
+        for member in ast.walk(node):
+            if isinstance(member, ast.Subscript) and semantics.imports.resolved_symbol(
+                member.value, sources=_TYPING_SOURCES
+            ) in {"ClassVar", "Final"}:
+                return True
+            if isinstance(member, ast.Name) and member.id in semantics.aliases and member.id not in seen:
+                seen.add(member.id)
+                pending.append(semantics.aliases[member.id])
+    return False
+
+
+class DeclaredContracts:
+    def __init__(self, context: PythonFileContext) -> None:
+        self.context = context
+        self._field_cache: dict[ast.ClassDef, dict[str, ast.AnnAssign]] = {}
+        self._module_annotations: dict[Path, AnnotationSemantics] = {}
+        self.project = context.session.project or ProjectIndexSet.single(context.path, context.source)
+        self.unit = self.project.unit(context.path)
+        if self.unit is not None and self.unit.tree is not context.tree:
+            self.unit = SourceUnit(self.unit.path, self.unit.module, self.unit.source, context.tree, self.unit.imports)
+            self.project = self.project.with_unit(self.unit)
+        if self.unit is not None and self.unit.module is None:
+            self.unit = SourceUnit(
+                context.path,
+                "__snippet__",
+                context.source,
+                context.tree,
+                {
+                    name: SymbolRef(target.module, target.symbol or "")
+                    for name, target in context.module_imports.bindings.items()
+                },
+            )
+            self.project = self.project.with_unit(self.unit)
+
+    def class_type(
+        self, expression: ast.expr, unit: SourceUnit | None = None, *, at: ast.AST | None = None
+    ) -> DeclaredClass | None:
+        owner = unit or self.unit
+        if owner is None or not self._lookup_allowed(expression, owner, at):
+            return None
+        summary = self.project.class_for(owner, expression)
+        source = self.project.source_unit(summary.symbol.module) if summary is not None else None
+        if source is None or source.tree is None or summary is None:
+            return None
+        declaration = self._stable_declaration(source, summary.symbol.name)
+        return DeclaredClass(source, declaration) if declaration is not None else None
+
+    def _lookup_allowed(self, expression: ast.expr, owner: SourceUnit, at: ast.AST | None) -> bool:
+        if owner is not self.unit or (at or expression) not in self.context.parents:
+            return True
+        root = expression
+        while isinstance(root, ast.Attribute):
+            root = root.value
+        if not isinstance(root, ast.Name):
+            return True
+        binding = self.context.static_resource_provenance.binding(root.id, at or expression)
+        return (
+            isinstance(binding, ast.alias | ast.ClassDef)
+            and root.id not in self.context.static_resource_provenance.mutated
+        )
+
+    def _stable_declaration(self, source: SourceUnit, name: str) -> ast.ClassDef | None:
+        if source.tree is None:
+            return None
+        declarations = [node for node in source.tree.body if isinstance(node, ast.ClassDef) and node.name == name]
+        if len(declarations) != 1 or declarations[0].keywords:
+            return None
+        if not self._identity_decorators(source, declarations[0]):
+            return None
+        if any(
+            isinstance(node, ast.Name) and node.id == name and isinstance(node.ctx, ast.Store | ast.Del)
+            for statement in source.tree.body
+            if not isinstance(statement, ast.ClassDef | ast.FunctionDef | ast.AsyncFunctionDef)
+            for node in ast.walk(statement)
+        ):
+            return None
+        return declarations[0]
+
+    def _identity_decorators(self, source: SourceUnit, declaration: ast.ClassDef) -> bool:
+        if not declaration.decorator_list:
+            return True
+        if source.tree is None:
+            return False
+        imports = (
+            self.context.module_imports
+            if source.path == self.context.path
+            else ImportIndex.from_tree(source.tree, module_scope_only=True)
+        )
+        return all(
+            imports.resolves(decorator, sources=_TYPING_SOURCES, symbol="final")
+            for decorator in declaration.decorator_list
+        )
+
+    def inherits(self, model: DeclaredClass, bases: frozenset[str]) -> bool:
+        return self.project.class_inherits_from(model.unit, model.declaration.name, bases)
+
+    def model_fields(self, model: DeclaredClass) -> dict[str, ast.AnnAssign]:
+        if model.unit.tree is None:
+            return {}
+        cached = self._field_cache.get(model.declaration)
+        if cached is not None:
+            return cached
+        semantics = self._module_semantics(model.unit)
+        fields = {
+            node.target.id: node
+            for node in model.declaration.body
+            if isinstance(node, ast.AnnAssign)
+            and isinstance(node.target, ast.Name)
+            and not node.target.id.startswith("_")
+            and node.target.id != "model_config"
+            and not _class_metadata_annotation(node.annotation, semantics)
+        }
+        self._field_cache[model.declaration] = fields
+        return fields
+
+    def _module_semantics(self, unit: SourceUnit) -> AnnotationSemantics:
+        if unit.tree is None:
+            return self.context.annotation_semantics
+        semantics = self._module_annotations.get(unit.path)
+        if semantics is None:
+            imports = (
+                self.context.module_imports
+                if unit.path == self.context.path
+                else ImportIndex.from_tree(unit.tree, module_scope_only=True)
+            )
+            semantics = AnnotationSemantics.from_imports(unit.tree, imports)
+            self._module_annotations[unit.path] = semantics
+        return semantics
+
+    def annotation(self, expression: ast.expr, unit: SourceUnit | None = None) -> DeclaredClass | None:
+        semantics = self.context.annotation_semantics
+        if unit is not None and unit is not self.unit and unit.tree is not None:
+            semantics = self._module_semantics(unit)
+        candidates = [
+            model
+            for member in semantics.transparent_members(expression)
+            if (model := self.class_type(member, unit, at=expression)) is not None
+        ]
+        return candidates[0] if len(candidates) == 1 else None
+
+    def value(self, expression: ast.expr, *, depth: int = 0) -> DeclaredClass | None:
+        if depth > _MAX_DEPTH:
+            return None
+        match expression:
+            case ast.Await():
+                return self.value(expression.value, depth=depth + 1)
+            case ast.Name():
+                return self._local_value(expression, depth)
+            case ast.Call():
+                return self.class_type(expression.func) or self._call_result(expression, depth)
+            case _:
+                return None
+
+    def _local_value(self, expression: ast.Name, depth: int) -> DeclaredClass | None:
+        binding = self.context.static_resource_provenance.binding(expression.id, expression)
+        if isinstance(binding, ast.arg) and binding.annotation is not None:
+            return self.annotation(binding.annotation)
+        parent = self.context.parents.get(binding) if binding is not None else None
+        if isinstance(parent, ast.AnnAssign):
+            return self.annotation(parent.annotation)
+        if isinstance(binding, ast.Name):
+            value = self.context.static_resource_provenance.assignment_value(binding, expression)
+            return self.value(value, depth=depth + 1) if value is not None else None
+        return None
+
+    def _call_result(self, expression: ast.Call, depth: int) -> DeclaredClass | None:
+        match expression.func:
+            case ast.Name():
+                binding = self.context.static_resource_provenance.binding(expression.func.id, expression)
+                if isinstance(binding, ast.FunctionDef | ast.AsyncFunctionDef) and binding.returns is not None:
+                    return self.annotation(binding.returns)
+                return None
+            case ast.Attribute():
+                return self._method_result(expression.func, depth)
+            case _:
+                return None
+
+    def _method_result(self, target: ast.Attribute, depth: int) -> DeclaredClass | None:
+        model = self.class_type(target.value) or self.value(target.value, depth=depth + 1)
+        if model is None:
+            return None
+        if target.attr in {"model_validate", "model_validate_json", "model_copy"} and self.inherits(
+            model, MODEL_BASES | SETTINGS_BASES
+        ):
+            return model
+        methods = [
+            node
+            for node in model.declaration.body
+            if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef) and node.name == target.attr
+        ]
+        if len(methods) == 1 and methods[0].returns is not None and not methods[0].decorator_list:
+            return self.annotation(methods[0].returns, model.unit)
+        return None
+
+
+def ordinary_pytest_test(function: ast.FunctionDef | ast.AsyncFunctionDef, context: PythonFileContext) -> bool:
+    if not function.name.startswith("test_"):
+        return False
+    owner = context.parents.get(function)
+    if isinstance(owner, ast.ClassDef) and (owner.bases or owner.decorator_list or owner.keywords):
+        return False
+    for decorator in function.decorator_list:
+        target = decorator.func if isinstance(decorator, ast.Call) else decorator
+        qualified = context.imports.resolved_qualified_name(target)
+        if qualified is None or not qualified.startswith("pytest.mark."):
+            return False
+    return True

{sarj_python_lint-1.67.0 → sarj_python_lint-1.69.0}/src/sarj_python_lint/rules/_local_source.py

@@ -15,7 +15,7 @@ if TYPE_CHECKING:
 
 _MAX_ANCESTORS = 24
 _MAX_MODULE_BYTES = 256_000
-_MAX_MODULES = 512
+LOCAL_SOURCE_CACHE_LIMIT = 512
 
 
 @dataclass(frozen=True, slots=True)
@@ -26,6 +26,12 @@ class LocalModule:
     runtime_imports: ImportIndex
 
 
+@dataclass(frozen=True, slots=True)
+class LocalSourceKeys:
+    resolutions: frozenset[tuple[Path, str | None, int]]
+    modules: frozenset[Path]
+
+
 @final
 class LocalSourceFacts:
     def __init__(self) -> None:
@@ -40,7 +46,7 @@ class LocalSourceFacts:
         key = (current, module, level)
         if key in self._resolutions:
             return self._resolutions[key]
-        if len(self._resolutions) >= _MAX_MODULES:
+        if len(self._resolutions) >= LOCAL_SOURCE_CACHE_LIMIT:
             return None
         result = _resolve_module(current, module, level, facts=facts)
         self._resolutions[key] = result
@@ -49,12 +55,16 @@ class LocalSourceFacts:
     def read_module(self, path: Path) -> LocalModule | None:
         if path in self._modules:
             return self._modules[path]
-        if len(self._modules) >= _MAX_MODULES:
+        if len(self._modules) >= LOCAL_SOURCE_CACHE_LIMIT:
             return None
         module = _read_module(path)
         self._modules[path] = module
         return module
 
+    def cache_keys(self) -> LocalSourceKeys:
+        # Failed lookups consume the same semantic budgets as successful ones.
+        return LocalSourceKeys(frozenset(self._resolutions), frozenset(self._modules))
+
 
 def _resolve_module(current: Path, module: str | None, level: int, *, facts: FirstPartyFacts) -> Path | None:
     if ".." in current.parts or level > _MAX_ANCESTORS:

{sarj_python_lint-1.67.0 → sarj_python_lint-1.69.0}/src/sarj_python_lint/rules/_project_index.py

@@ -154,6 +154,20 @@ class LoadedSource:
     source: str
 
 
+@dataclass(frozen=True, slots=True)
+class _IndexedSource:
+    key: Path
+    path: Path
+    module: str | None
+    source: str
+
+
+@dataclass(frozen=True, slots=True)
+class ProjectSourceSnapshot:
+    roots: tuple[Path, ...]
+    units: tuple[_IndexedSource, ...]
+
+
 @dataclass(frozen=True, slots=True)
 class _ClassValueUse:
     reference: ast.Name | ast.Attribute
@@ -196,6 +210,30 @@ class ProjectIndexSet:
         self._classes = MappingProxyType(classes)
         self._nominals = MappingProxyType({key: frozenset(value) for key, value in nominals.items()})
 
+    def source_snapshot(self) -> ProjectSourceSnapshot:
+        # Rebuild memoized facts without rescanning roots or changing the
+        # module identities/order of the complete prepared source graph.
+        return ProjectSourceSnapshot(
+            self._roots,
+            tuple(_IndexedSource(key, unit.path, unit.module, unit.source) for key, unit in self._units.items()),
+        )
+
+    @classmethod
+    def from_source_snapshot(cls, snapshot: ProjectSourceSnapshot) -> Self:
+        units: dict[Path, SourceUnit] = {}
+        for source in snapshot.units:
+            tree: ast.Module | None = None
+            with suppress(SyntaxError):
+                tree = ast.parse(source.source, filename=str(source.path))
+            units[source.key] = SourceUnit(
+                path=source.path,
+                module=source.module,
+                source=source.source,
+                tree=tree,
+                imports=MappingProxyType(_imports(source.module, tree, is_package=source.path.name == "__init__.py")),
+            )
+        return cls(units, snapshot.roots)
+
     @classmethod
     def build(
         cls,

{sarj_python_lint-1.67.0 → sarj_python_lint-1.69.0}/src/sarj_python_lint/rules/_registry.py

@@ -237,8 +237,13 @@ from sarj_python_lint.rules.no_slash_collection_root_under_prefix import NoSlash
 from sarj_python_lint.rules.no_unknown_pydantic_validator_field import NoUnknownPydanticValidatorField
 from sarj_python_lint.rules.no_work_verb_get_route import NoWorkVerbGetRoute
 from sarj_python_lint.rules.prefer_bulk_upsert import PreferBulkUpsert
+from sarj_python_lint.rules.prefer_direct_import_module import PreferDirectImportModule
 from sarj_python_lint.rules.prefer_discriminated_model_union import PreferDiscriminatedModelUnion
+from sarj_python_lint.rules.prefer_precise_object_contract import PreferPreciseObjectContract
 from sarj_python_lint.rules.prefer_psycopg_executemany import PreferPsycopgExecutemany
+from sarj_python_lint.rules.prefer_pydantic_model_assertion import PreferPydanticModelAssertion
+from sarj_python_lint.rules.prefer_pytest_dependency_fixtures import PreferPytestDependencyFixtures
+from sarj_python_lint.rules.prefer_typed_settings_field import PreferTypedSettingsField
 from sarj_python_lint.rules.pytest_fixture_returns_closed_resource import PytestFixtureReturnsClosedResource
 from sarj_python_lint.rules.redundant_test_constructor_forwarder import RedundantTestConstructorForwarder
 from sarj_python_lint.rules.repeated_unimplemented_test_contract import RepeatedUnimplementedTestContract
@@ -251,6 +256,11 @@ REGISTRY: Mapping[str, type[Rule]] = MappingProxyType(
     {
         PytestFixtureReturnsClosedResource.id: PytestFixtureReturnsClosedResource,
         DuplicatePytestFixtureParams.id: DuplicatePytestFixtureParams,
+        PreferTypedSettingsField.id: PreferTypedSettingsField,
+        PreferDirectImportModule.id: PreferDirectImportModule,
+        PreferPreciseObjectContract.id: PreferPreciseObjectContract,
+        PreferPydanticModelAssertion.id: PreferPydanticModelAssertion,
+        PreferPytestDependencyFixtures.id: PreferPytestDependencyFixtures,
         PreferBulkUpsert.id: PreferBulkUpsert,
         PreferPsycopgExecutemany.id: PreferPsycopgExecutemany,
         StoreFieldUpdateReusesUpsert.id: StoreFieldUpdateReusesUpsert,

{sarj_python_lint-1.67.0 → sarj_python_lint-1.69.0}/src/sarj_python_lint/rules/_test_composition.py

@@ -65,7 +65,13 @@ def _class_owner(
     return unit, owner
 
 
-def constructor(context: PythonFileContext, expression: ast.expr, project: ProjectIndexSet) -> Constructor | None:
+def constructor(
+    context: PythonFileContext,
+    expression: ast.expr,
+    project: ProjectIndexSet,
+    *,
+    minimum_collaborators: int = _MIN_COLLABORATORS,
+) -> Constructor | None:
     resolved = _class_owner(context, expression, project)
     if resolved is None:
         return None
@@ -87,7 +93,7 @@ def constructor(context: PythonFileContext, expression: ast.expr, project: Proje
         and _is_port(project, unit, parameter.annotation)
         and stored.get(parameter.arg) in invoked
     )
-    if len(collaborators) < _MIN_COLLABORATORS:
+    if len(collaborators) < minimum_collaborators:
         return None
     return Constructor(
         SymbolRef(unit.module, owner.name),