sarj-python-lint 0.84.3__tar.gz → 0.85.0__tar.gz

{sarj_python_lint-0.84.3 → sarj_python_lint-0.85.0}/PKG-INFO

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

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

{sarj_python_lint-0.84.3 → sarj_python_lint-0.85.0}/src/sarj_python_lint/__main__.py

@@ -143,6 +143,10 @@ _DIAGNOSTIC_PRECEDENCE = MappingProxyType(
         "SARJ092": frozenset({"SARJ086", "SARJ087", "SARJ420"}),
         "SARJ093": frozenset({"SARJ034"}),
         "SARJ099": frozenset({"SARJ420"}),
+        # Any-valued mappings are the stronger correctness failure. SARJ008
+        # still owns every fixed dictionary return when selected alone, while
+        # an all-rules run emits one actionable diagnostic for this overlap.
+        "SARJ447": frozenset({"SARJ008"}),
     }
 )
 
@@ -162,13 +166,13 @@ def deduplicate_diagnostics(diags: list[Diagnostic], *, source: str | None = Non
         "SARJ420" in codes and not codes.isdisjoint(_DOCSTRING_PRECEDENCE_CODES)
     )
     docstring_owners = _docstring_owner_locations(source) if source is not None and needs_docstring_owners else {}
-    needs_signature_owners = "SARJ093" in codes and "SARJ034" in codes
+    needs_signature_owners = ("SARJ093" in codes and "SARJ034" in codes) or ("SARJ447" in codes and "SARJ008" in codes)
     signature_owners = (
         _function_signature_owner_locations(source) if source is not None and needs_signature_owners else {}
     )
 
     def owner_location(diagnostic: Diagnostic) -> _OwnerLocation:
-        if diagnostic.code in {"SARJ034", "SARJ093"}:
+        if diagnostic.code in {"SARJ008", "SARJ034", "SARJ093", "SARJ447"}:
             line, column = signature_owners.get(diagnostic.line, (diagnostic.line, diagnostic.col))
         else:
             line, column = docstring_owners.get(diagnostic.line, (diagnostic.line, diagnostic.col))

{sarj_python_lint-0.84.3 → sarj_python_lint-0.85.0}/src/sarj_python_lint/rules/_fastapi.py

@@ -5,6 +5,8 @@ from collections import Counter
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Literal, NamedTuple
 
+from sarj_python_lint.rules._imports import ImportIndex
+
 
 if TYPE_CHECKING:
     from pathlib import Path
@@ -107,6 +109,7 @@ class FastapiIndex:
     def __init__(self, tree: ast.Module, *, path: Path | None = None) -> None:
         self.tree: ast.Module = tree
         self.path: Path | None = path
+        self.imports: ImportIndex = ImportIndex.from_tree(tree, module_scope_only=True)
         self._imported_dependency_cache: dict[_ImportedReference, bool] = {}
         self._imported_module_cache: dict[Path, ast.Module | None] = {}
         self.modules: set[str] = set()

{sarj_python_lint-0.84.3 → sarj_python_lint-0.85.0}/src/sarj_python_lint/rules/_imports.py

@@ -44,6 +44,12 @@ class ImportIndex:
             return None
         return resolved.symbol
 
+    def resolved_qualified_name(self, node: ast.expr) -> str | None:
+        resolved = self._resolve(node)
+        if resolved is None or resolved.symbol is None:
+            return None
+        return f"{resolved.module}.{resolved.symbol}"
+
     def builtin_is_unshadowed(self, name: str) -> bool:
         return name not in self.shadowed_names and name not in self.bindings
 

{sarj_python_lint-0.84.3 → sarj_python_lint-0.85.0}/src/sarj_python_lint/rules/_registry.py

@@ -22,12 +22,14 @@ from sarj_python_lint.rules.invalid_pydantic_field_default import (
     InvalidPydanticFieldDefault,
 )
 from sarj_python_lint.rules.mock_without_spec import MockWithoutSpec
+from sarj_python_lint.rules.named_record_at_boundaries import NamedRecordAtBoundaries
 from sarj_python_lint.rules.negative_only_http_status_assertion import (
     NegativeOnlyHttpStatusAssertion,
 )
 from sarj_python_lint.rules.no_analytical_aggregation_in_postgres_store import (
     NoAnalyticalAggregationInPostgresStore,
 )
+from sarj_python_lint.rules.no_any_mapping_types import NoAnyMappingTypes
 from sarj_python_lint.rules.no_comment_cruft import NoCommentCruft
 from sarj_python_lint.rules.no_conftest_test_module_import import NoConftestTestModuleImport
 from sarj_python_lint.rules.no_copied_inherited_docstring import NoCopiedInheritedDocstring
@@ -78,7 +80,6 @@ from sarj_python_lint.rules.no_unique_violation_message_match import (
 )
 from sarj_python_lint.rules.no_unnecessary_docstring import NoUnnecessaryDocstring
 from sarj_python_lint.rules.no_unused_value_marker import NoUnusedValueMarker
-from sarj_python_lint.rules.no_vague_annotations import NoVagueAnnotations
 from sarj_python_lint.rules.no_vague_suppression_description import (
     NoVagueSuppressionDescription,
 )
@@ -102,6 +103,7 @@ from sarj_python_lint.rules.prefer_injected_dependency_over_monkeypatch import (
 )
 from sarj_python_lint.rules.prefer_library_fake import PreferLibraryFake
 from sarj_python_lint.rules.prefer_match_assert_never import PreferMatchAssertNever
+from sarj_python_lint.rules.prefer_match_exception_dispatch import PreferMatchExceptionDispatch
 from sarj_python_lint.rules.prefer_match_type_dispatch import PreferMatchTypeDispatch
 from sarj_python_lint.rules.prefer_match_value_dispatch import PreferMatchValueDispatch
 from sarj_python_lint.rules.prefer_module_level_constant import (
@@ -134,7 +136,6 @@ from sarj_python_lint.rules.prefer_walrus_comprehension_filter import (
 from sarj_python_lint.rules.prefer_walrus_regex_match import PreferWalrusRegexMatch
 from sarj_python_lint.rules.prefer_walrus_stream_loop import PreferWalrusStreamLoop
 from sarj_python_lint.rules.production_derived_test_cases import ProductionDerivedTestCases
-from sarj_python_lint.rules.pydantic_at_boundaries import PydanticAtBoundaries
 from sarj_python_lint.rules.pytest_fixture_returns_bare_tuple import PytestFixtureReturnsBareTuple
 from sarj_python_lint.rules.redundant_class_docstring import RedundantClassDocstring
 from sarj_python_lint.rules.redundant_docstring import RedundantDocstring
@@ -189,7 +190,7 @@ REGISTRY: Mapping[str, type[Rule]] = MappingProxyType(
         NoExcessiveCognitiveComplexity.id: NoExcessiveCognitiveComplexity,
         PreferNamedtupleOverTupleReturn.id: PreferNamedtupleOverTupleReturn,
         NoCorsWildcardWithCredentials.id: NoCorsWildcardWithCredentials,
-        PydanticAtBoundaries.id: PydanticAtBoundaries,
+        NamedRecordAtBoundaries.id: NamedRecordAtBoundaries,
         FastapiExplicitOpenapiContract.id: FastapiExplicitOpenapiContract,
         FastapiClassRouterContract.id: FastapiClassRouterContract,
         FakesInSharedLocation.id: FakesInSharedLocation,
@@ -243,6 +244,7 @@ REGISTRY: Mapping[str, type[Rule]] = MappingProxyType(
         PreferOrPattern.id: PreferOrPattern,
         RequirePortForService.id: RequirePortForService,
         PreferNonNullableCollection.id: PreferNonNullableCollection,
+        PreferMatchExceptionDispatch.id: PreferMatchExceptionDispatch,
         PreferMatchTypeDispatch.id: PreferMatchTypeDispatch,
         PreferMatchValueDispatch.id: PreferMatchValueDispatch,
         PreferWalrusRegexMatch.id: PreferWalrusRegexMatch,
@@ -267,7 +269,7 @@ REGISTRY: Mapping[str, type[Rule]] = MappingProxyType(
         NoUnnecessaryDocstring.id: NoUnnecessaryDocstring,
         NoUnusedValueMarker.id: NoUnusedValueMarker,
         PreferNominalIdTypes.id: PreferNominalIdTypes,
-        NoVagueAnnotations.id: NoVagueAnnotations,
+        NoAnyMappingTypes.id: NoAnyMappingTypes,
         NoUniqueViolationMessageMatch.id: NoUniqueViolationMessageMatch,
         NegativeOnlyHttpStatusAssertion.id: NegativeOnlyHttpStatusAssertion,
         ProductionDerivedTestCases.id: ProductionDerivedTestCases,

{sarj_python_lint-0.84.3 → sarj_python_lint-0.85.0}/src/sarj_python_lint/rules/fastapi_explicit_openapi_contract.py

@@ -425,18 +425,41 @@ def _schema_erasing(node: ast.expr, index: FastapiIndex) -> bool:
         return _schema_erasing(parts[0], index)
     if isinstance(resolved, ast.BinOp) and isinstance(resolved.op, ast.BitOr):
         return _schema_erasing(resolved.left, index) or _schema_erasing(resolved.right, index)
-    name = flat_name(resolved.value) if isinstance(resolved, ast.Subscript) else flat_name(resolved)
-    if name in {"Any", "object"}:
+    target = resolved.value if isinstance(resolved, ast.Subscript) else resolved
+    if _is_typing_type(target, index, "Any") or _is_builtin_type(target, index, "object"):
         return True
-    if name in _RAW_MAPPINGS or name in _CONTAINERS:
+    if index.imports.resolves(target, sources=frozenset({"pydantic"}), symbol="JsonValue"):
+        return True
+    if _is_container_type(target, index, _RAW_MAPPINGS | _CONTAINERS):
         if not isinstance(resolved, ast.Subscript):
             return True
         return any(_schema_erasing(item, index) for item in _slice_items(resolved.slice))
-    if isinstance(resolved, ast.Subscript) and name in {"Optional", "Union"}:
+    if isinstance(resolved, ast.Subscript) and any(
+        _is_typing_type(target, index, wrapper) for wrapper in ("Optional", "Union")
+    ):
         return any(_schema_erasing(item, index) for item in _slice_items(resolved.slice))
     return False
 
 
+def _is_builtin_type(node: ast.expr, index: FastapiIndex, name: str) -> bool:
+    return (
+        isinstance(node, ast.Name) and node.id == name and index.imports.builtin_is_unshadowed(name)
+    ) or index.imports.resolves(node, sources=frozenset({"builtins"}), symbol=name)
+
+
+def _is_typing_type(node: ast.expr, index: FastapiIndex, name: str) -> bool:
+    return index.imports.resolves(node, sources=frozenset({"typing", "typing_extensions"}), symbol=name)
+
+
+def _is_container_type(node: ast.expr, index: FastapiIndex, names: frozenset[str]) -> bool:
+    builtin_names = {"dict", "list", "set", "tuple"}
+    return any(
+        (name in builtin_names and _is_builtin_type(node, index, name))
+        or index.imports.resolves(node, sources=frozenset({"collections.abc", "typing"}), symbol=name)
+        for name in names
+    )
+
+
 def _slice_items(node: ast.expr) -> tuple[ast.expr, ...]:
     return tuple(node.elts) if isinstance(node, ast.Tuple) else (node,)
 

sarj_python_lint-0.84.3/src/sarj_python_lint/rules/pydantic_at_boundaries.py → sarj_python_lint-0.85.0/src/sarj_python_lint/rules/named_record_at_boundaries.py

@@ -36,15 +36,15 @@ _DICT_ARG_COUNT = 2
 _DOCUMENTATION_DIR_NAMES = frozenset({"docs", "docs_src"})
 
 
-class PydanticAtBoundaries(Rule):
-    id: str = "pydantic-at-boundaries"
+class NamedRecordAtBoundaries(Rule):
+    id: str = "named-record-at-boundaries"
     code: str = "SARJ008"
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
         summary="Public Python API returns an unnamed fixed-shape record.",
         rationale="A named record makes field types and required keys explicit to callers and static tooling.",
         remediation="Define and return a `TypedDict`, Pydantic model, or frozen dataclass for the fixed record shape.",
         category=RuleCategory.ARCHITECTURE,
-        aliases=("named-fixed-record-return",),
+        aliases=("pydantic-at-boundaries", "named-fixed-record-return"),
         limitations=(
             "Visible FastAPI routes are owned by SARJ094. Private functions and classes, closures, tests, generated files, documentation examples, recognized framework hooks, and dictionary conversion methods are excluded.",
             "Only returned record literals and locally built fixed-shape dictionaries are recognized.",
@@ -57,7 +57,7 @@ class PydanticAtBoundaries(Rule):
                 files=(
                     ExampleFile.python(
                         "service.py",
-                        "from typing import Any\n\ndef build_payload(call) -> dict[str, Any]:\n    return {'id': call.id}\n",
+                        "def build_payload(call) -> dict[str, object]:\n    return {'id': call.id}\n",
                     ),
                 ),
                 focus_path=PurePosixPath("service.py"),
@@ -250,24 +250,23 @@ def _classify_return(node: ast.expr, imports: ImportIndex) -> str | None:
     if _is_typing_type(node.value, imports, "Union"):
         return _classify_union_return(node, imports)
     if _is_type(node.value, imports, builtin="list", typing_symbol="List"):
-        # Only list-of-untyped-dict is flagged (e.g. `list[dict[str, Any]]`).
+        # Fixed lists of unnamed records need one named element contract.
         inner = _classify_return(node.slice, imports)
         return "dict" if inner == "dict" else None
     if _is_type(node.value, imports, builtin="dict", typing_symbol="Dict"):
-        return "dict" if _is_untyped_dict_args(node.slice, imports) else None
+        return "dict" if _is_named_record_dict_args(node.slice, imports) else None
     # Heterogeneous tuple returns are NOT flagged — multiple return values are
     # idiomatic Python, not a missing data contract.
     return None
 
 
-def _is_untyped_dict_args(slice_node: ast.expr, imports: ImportIndex) -> bool:
+def _is_named_record_dict_args(slice_node: ast.expr, imports: ImportIndex) -> bool:
     if not isinstance(slice_node, ast.Tuple) or len(slice_node.elts) != _DICT_ARG_COUNT:
         return False
     key = _resolve_annotation(slice_node.elts[0])
     if key is None or not _is_builtin(key, imports, "str"):
         return False
-    value = _resolve_annotation(slice_node.elts[1])
-    return value is not None and (_is_builtin(value, imports, "object") or _is_typing_type(value, imports, "Any"))
+    return _resolve_annotation(slice_node.elts[1]) is not None
 
 
 def _is_type(node: ast.expr, imports: ImportIndex, *, builtin: str, typing_symbol: str) -> bool:

sarj_python_lint-0.85.0/src/sarj_python_lint/rules/no_any_mapping_types.py

@@ -0,0 +1,257 @@
+from __future__ import annotations
+
+import ast
+from pathlib import PurePosixPath
+from typing import TYPE_CHECKING, ClassVar, final, override
+
+from sarj_python_lint.rule_base import (
+    AutofixPolicy,
+    Diagnostic,
+    ExampleFile,
+    ExampleOutcome,
+    Rule,
+    RuleCategory,
+    RuleDocumentation,
+    RuleExample,
+    is_suppressed,
+)
+from sarj_python_lint.rules._imports import ImportIndex
+from sarj_python_lint.rules._paths import is_generated
+
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+_TYPING_SOURCES = frozenset({"typing", "typing_extensions"})
+_PYDANTIC_SOURCES = frozenset({"pydantic"})
+_MAPPING_SOURCES = frozenset({"collections.abc", "typing"})
+_MAPPING_NAMES = frozenset({"dict", "Dict", "Mapping", "MutableMapping"})
+_MAPPING_ARGUMENT_COUNT = 2
+
+
+@final
+class NoAnyMappingTypes(Rule):
+    id = "no-any-mapping-types"
+    code = "SARJ447"
+    documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
+        summary="String-keyed mapping types must not erase their values with `Any`.",
+        rationale=(
+            "An `Any`-valued mapping disables checking transitively and conceals whether the value is a fixed record, "
+            "an arbitrary JSON tree, or a genuinely opaque Python object."
+        ),
+        remediation=(
+            "Use `TypedDict` (and `Unpack[TypedDict]` for closed keyword arguments) for fixed records, a Pydantic model "
+            "for untrusted runtime input, `pydantic.JsonValue` for arbitrary JSON, or `object` plus explicit narrowing "
+            "for a genuinely opaque Python value."
+        ),
+        category=RuleCategory.CORRECTNESS,
+        autofix=AutofixPolicy.NONE,
+        aliases=("no-vague-annotations",),
+        limitations=(
+            (
+                "Only proven built-in or standard-library string-keyed mappings whose value recursively contains "
+                "`typing.Any` are reported; `object` is intentionally not treated as `Any`."
+            ),
+            "Generated and vendored sources are excluded; exact local suppressions remain auditable.",
+        ),
+        examples=(
+            RuleExample(
+                example_id="any-valued-mapping-annotation",
+                title="An Any-valued mapping erases the record schema",
+                outcome=ExampleOutcome.MATCH,
+                files=(
+                    ExampleFile.python(
+                        "app/offers.py", "from typing import Any\ndef details() -> dict[str, Any]: ...\n"
+                    ),
+                ),
+                focus_path=PurePosixPath("app/offers.py"),
+                expected_count=1,
+                public=True,
+            ),
+            RuleExample(
+                example_id="typed-dictionary-annotation",
+                title="A TypedDict preserves the record schema",
+                outcome=ExampleOutcome.NO_MATCH,
+                files=(
+                    ExampleFile.python(
+                        "app/offers.py",
+                        "from typing import TypedDict\nclass OfferDetails(TypedDict):\n    id: str\ndef details() -> OfferDetails: ...\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("app/offers.py"),
+                expected_count=0,
+                public=True,
+            ),
+        ),
+    )
+    description = documentation.summary
+
+    @override
+    def check(self, path: Path, source: str) -> list[Diagnostic]:
+        if is_generated(path, source) or _is_vendor_path(path):
+            return []
+        try:
+            tree = ast.parse(source, filename=str(path), type_comments=True)
+        except SyntaxError:
+            return []
+        imports = ImportIndex.from_tree(tree, module_scope_only=True)
+        aliases = _type_aliases(tree, imports)
+        lines = source.splitlines()
+        findings: list[Diagnostic] = []
+        seen: set[tuple[int, int]] = set()
+        for expression in _type_expressions(tree, imports):
+            for mapping in _any_mappings(expression, imports, aliases):
+                location = expression if isinstance(expression, ast.Constant) else mapping
+                key = (location.lineno, location.col_offset)
+                if key in seen or is_suppressed(lines, location.lineno, self.code):
+                    continue
+                seen.add(key)
+                findings.append(
+                    Diagnostic(
+                        path=path,
+                        line=location.lineno,
+                        col=location.col_offset + 1,
+                        code=self.code,
+                        message=(
+                            f"mapping type `{ast.unparse(mapping)}` contains `Any`; use `TypedDict` for a fixed "
+                            "record, `pydantic.JsonValue` for arbitrary JSON, or `object` with narrowing for opaque values"
+                        ),
+                    )
+                )
+        return sorted(findings, key=lambda finding: (finding.line, finding.col))
+
+
+def _type_expressions(tree: ast.Module, imports: ImportIndex) -> list[ast.expr]:
+    expressions = [annotation for node in ast.walk(tree) if (annotation := _node_annotation(node, imports)) is not None]
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.Call) or not node.args:
+            continue
+        if imports.resolves(node.func, sources=_TYPING_SOURCES, symbol="cast") or imports.resolves(
+            node.func, sources=_PYDANTIC_SOURCES, symbol="TypeAdapter"
+        ):
+            expressions.append(node.args[0])
+    return expressions
+
+
+def _node_annotation(node: ast.AST, imports: ImportIndex) -> ast.expr | None:
+    match node:
+        case (
+            ast.arg(annotation=annotation)
+            | ast.FunctionDef(returns=annotation)
+            | ast.AsyncFunctionDef(returns=annotation)
+        ):
+            return annotation
+        case ast.AnnAssign(annotation=annotation, value=value) if value is not None:
+            if imports.resolves(annotation, sources=_TYPING_SOURCES, symbol="TypeAlias"):
+                return value
+            return annotation
+        case ast.AnnAssign(annotation=annotation):
+            return annotation
+        case ast.TypeAlias(value=value):
+            return value
+        case (
+            ast.Assign(type_comment=str(comment))
+            | ast.For(type_comment=str(comment))
+            | ast.AsyncFor(type_comment=str(comment))
+            | ast.With(type_comment=str(comment))
+            | ast.AsyncWith(type_comment=str(comment))
+        ):
+            return _type_comment(comment, node)
+        case _:
+            return None
+
+
+def _type_comment(comment: str, owner: ast.AST) -> ast.expr | None:
+    try:
+        expression = ast.parse(comment, mode="eval").body
+    except SyntaxError:
+        return None
+    ast.copy_location(expression, owner)
+    return expression
+
+
+def _parse_string_annotation(annotation: ast.expr) -> ast.expr:
+    if not isinstance(annotation, ast.Constant) or not isinstance(annotation.value, str):
+        return annotation
+    try:
+        parsed = ast.parse(annotation.value, mode="eval").body
+    except SyntaxError:
+        return annotation
+    ast.copy_location(parsed, annotation)
+    return parsed
+
+
+def _any_mappings(annotation: ast.expr, imports: ImportIndex, aliases: dict[str, ast.expr]) -> list[ast.Subscript]:
+    resolved = _parse_string_annotation(annotation)
+    return [
+        node
+        for node in ast.walk(resolved)
+        if isinstance(node, ast.Subscript) and _is_any_mapping(node, imports, aliases)
+    ]
+
+
+def _is_any_mapping(node: ast.Subscript, imports: ImportIndex, aliases: dict[str, ast.expr]) -> bool:
+    if not isinstance(node.slice, ast.Tuple) or len(node.slice.elts) != _MAPPING_ARGUMENT_COUNT:
+        return False
+    target = node.value
+    mapping = (isinstance(target, ast.Name) and target.id == "dict" and imports.builtin_is_unshadowed("dict")) or any(
+        imports.resolves(target, sources=_MAPPING_SOURCES, symbol=name) for name in _MAPPING_NAMES
+    )
+    if not mapping:
+        return False
+    key, value = node.slice.elts
+    return _is_builtin_str(key, imports) and _contains_any(value, imports, aliases, seen=frozenset())
+
+
+def _is_builtin_str(node: ast.expr, imports: ImportIndex) -> bool:
+    return isinstance(node, ast.Name) and node.id == "str" and imports.builtin_is_unshadowed("str")
+
+
+def _contains_any(
+    node: ast.expr,
+    imports: ImportIndex,
+    aliases: dict[str, ast.expr],
+    *,
+    seen: frozenset[str],
+) -> bool:
+    node = _parse_string_annotation(node)
+    if imports.resolves(node, sources=_TYPING_SOURCES, symbol="Any"):
+        return True
+    if isinstance(node, ast.Name) and node.id in aliases and node.id not in seen:
+        return _contains_any(aliases[node.id], imports, aliases, seen=seen | {node.id})
+    return any(
+        _contains_any(child, imports, aliases, seen=seen)
+        for child in ast.iter_child_nodes(node)
+        if isinstance(child, ast.expr)
+    )
+
+
+def _type_aliases(tree: ast.Module, imports: ImportIndex) -> dict[str, ast.expr]:
+    aliases: dict[str, ast.expr] = {}
+    ambiguous: set[str] = set()
+    for statement in tree.body:
+        name: str | None = None
+        value: ast.expr | None = None
+        match statement:
+            case ast.TypeAlias(name=ast.Name(id=alias), value=alias_value, type_params=[]):
+                name, value = alias, alias_value
+            case ast.AnnAssign(target=ast.Name(id=alias), annotation=annotation, value=alias_value) if (
+                alias_value is not None and imports.resolves(annotation, sources=_TYPING_SOURCES, symbol="TypeAlias")
+            ):
+                name, value = alias, alias_value
+            case _:
+                pass
+        if name is None or value is None:
+            continue
+        if name in aliases:
+            ambiguous.add(name)
+        else:
+            aliases[name] = value
+    for name in ambiguous:
+        aliases.pop(name, None)
+    return aliases
+
+
+def _is_vendor_path(path: Path) -> bool:
+    return any(part.casefold() in {"vendor", "vendored", "third_party"} for part in path.parts)