sarj-python-lint 0.80.5__tar.gz → 0.80.8__tar.gz

{sarj_python_lint-0.80.5 → sarj_python_lint-0.80.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 0.80.5
+Version: 0.80.8
 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/
@@ -18,6 +18,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: >=3.14
 Requires-Dist: ruff>=0.16.5
+Requires-Dist: sqlglot==30.18.0
 Description-Content-Type: text/markdown
 
 <!-- Generated by `code-standards maintain docs sync`; do not edit. -->

{sarj_python_lint-0.80.5 → sarj_python_lint-0.80.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sarj-python-lint"
-version = "0.80.5"
+version = "0.80.8"
 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 = ["ruff>=0.16.5"]
+dependencies = ["ruff>=0.16.5", "sqlglot==30.18.0"]
 
 [project.scripts]
 sarj-python-lint = "sarj_python_lint.__main__:main"

{sarj_python_lint-0.80.5 → sarj_python_lint-0.80.8}/src/sarj_python_lint/__main__.py

@@ -125,14 +125,12 @@ def analyze(
 
 _DIAGNOSTIC_PRECEDENCE = MappingProxyType(
     {
-        "SARJ003": frozenset({"SARJ080"}),
         "SARJ050": frozenset({"SARJ420"}),
-        "SARJ084": frozenset({"SARJ050", "SARJ091", "SARJ420"}),
+        "SARJ084": frozenset({"SARJ050", "SARJ420"}),
         "SARJ085": frozenset({"SARJ420"}),
         "SARJ086": frozenset({"SARJ420"}),
         "SARJ087": frozenset({"SARJ420"}),
-        "SARJ088": frozenset({"SARJ050", "SARJ085", "SARJ091", "SARJ420"}),
-        "SARJ091": frozenset({"SARJ420"}),
+        "SARJ088": frozenset({"SARJ050", "SARJ085", "SARJ420"}),
         "SARJ092": frozenset({"SARJ086", "SARJ087", "SARJ420"}),
         "SARJ093": frozenset({"SARJ034"}),
         "SARJ099": frozenset({"SARJ420"}),
@@ -140,7 +138,7 @@ _DIAGNOSTIC_PRECEDENCE = MappingProxyType(
 )
 
 _DOCSTRING_PRECEDENCE_CODES = frozenset(
-    {"SARJ050", "SARJ084", "SARJ085", "SARJ086", "SARJ087", "SARJ088", "SARJ091", "SARJ092", "SARJ099"}
+    {"SARJ050", "SARJ084", "SARJ085", "SARJ086", "SARJ087", "SARJ088", "SARJ092", "SARJ099"}
 )
 
 

{sarj_python_lint-0.80.5 → sarj_python_lint-0.80.8}/src/sarj_python_lint/rules/_fastapi.py

@@ -41,6 +41,8 @@ class Route:
     path: str | None
     receiver_kind: Literal["FastAPI", "APIRouter"]
     inherited_hidden: bool = False
+    inherited_responses: ast.expr | None = None
+    inherited_response_class: ast.expr | None = None
 
     @property
     def keywords(self) -> dict[str, ast.expr]:
@@ -119,6 +121,7 @@ class FastapiIndex:
         self.receiver_origins: dict[_ReceiverKey, _ReceiverKey] = {}
         self.receiver_kinds: dict[_ReceiverKey, Literal["FastAPI", "APIRouter"]] = {}
         self.hidden_receivers: set[_ReceiverKey] = set()
+        self.receiver_defaults: dict[_ReceiverKey, dict[str, ast.expr]] = {}
         self.decorators: dict[_ReceiverKey, _DecoratorBinding] = {}
         self.bound_names: set[_ReceiverKey] = set()
         self._node_scopes: dict[int, int] = {}
@@ -243,6 +246,12 @@ class FastapiIndex:
                     self.receivers.add(key)
                     self.receiver_origins[key] = key
                     self.receiver_kinds[key] = constructor_kind
+                    if isinstance(value, ast.Call):
+                        self.receiver_defaults[key] = {
+                            keyword.arg: keyword.value
+                            for keyword in value.keywords
+                            if keyword.arg in {"responses", "default_response_class"}
+                        }
                     if self._constructor_is_hidden(value):
                         self.hidden_receivers.add(key)
                     changed = True
@@ -346,6 +355,7 @@ class FastapiIndex:
             path = path_node.value if isinstance(path_node, ast.Constant) and isinstance(path_node.value, str) else None
             route_methods = self._route_methods(decorator) if method == "api_route" else (method,)
             origin = self.receiver_origins[receiver_key]
+            defaults = self.receiver_defaults.get(origin, {})
             routes.extend(
                 Route(
                     decorator=decorator,
@@ -354,6 +364,8 @@ class FastapiIndex:
                     path=path,
                     receiver_kind=self.receiver_kinds[receiver_key],
                     inherited_hidden=receiver_key in self.hidden_receivers,
+                    inherited_responses=defaults.get("responses"),
+                    inherited_response_class=defaults.get("default_response_class"),
                 )
                 for route_method in route_methods
             )

sarj_python_lint-0.80.8/src/sarj_python_lint/rules/_fixed_record.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import ast
+
+from sarj_python_lint.rules._ast_index import children
+
+
+_RECORD_MUTATOR_METHODS = frozenset({"clear", "pop", "popitem", "setdefault", "update"})
+
+
+def builds_fixed_record(node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
+    returned: list[ast.expr] = []
+    record_names = {
+        target.id
+        for current in _owned_nodes(node)
+        if isinstance(current, ast.Assign) and _is_record_literal(current.value)
+        for target in current.targets
+        if isinstance(target, ast.Name)
+    }
+    record_names.update(
+        current.target.id
+        for current in _owned_nodes(node)
+        if isinstance(current, ast.AnnAssign)
+        and isinstance(current.target, ast.Name)
+        and current.value is not None
+        and _is_record_literal(current.value)
+    )
+    invalidated_names: set[str] = set()
+    aliases: dict[str, str] = {}
+    stack: list[ast.AST] = list(node.body)
+    while stack:
+        current = stack.pop()
+        if isinstance(current, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef, ast.Lambda)):
+            continue
+        if isinstance(current, ast.Return) and current.value is not None:
+            returned.append(current.value)
+        elif isinstance(current, ast.Assign) and _is_record_literal(current.value):
+            for target in current.targets:
+                if isinstance(target, ast.Subscript):
+                    invalidated_names.update(_mutated_record_roots(target))
+        elif isinstance(current, ast.Assign):
+            if isinstance(current.value, ast.Name):
+                for target in current.targets:
+                    if not isinstance(target, ast.Name):
+                        continue
+                    if target.id in record_names:
+                        invalidated_names.add(target.id)
+                    else:
+                        aliases[target.id] = current.value.id
+            else:
+                invalidated_names.update(
+                    target.id for target in current.targets if isinstance(target, ast.Name)
+                )
+            for target in current.targets:
+                if isinstance(target, ast.Subscript):
+                    invalidated_names.update(_mutated_record_roots(target))
+        elif (
+            isinstance(current, ast.AnnAssign)
+            and isinstance(current.target, ast.Name)
+            and current.value is not None
+            and _is_record_literal(current.value)
+        ):
+            pass
+        elif (
+            isinstance(current, ast.AnnAssign)
+            and isinstance(current.target, ast.Name)
+            and isinstance(current.value, ast.Name)
+        ):
+            if current.target.id in record_names:
+                invalidated_names.add(current.target.id)
+            else:
+                aliases[current.target.id] = current.value.id
+        elif isinstance(current, (ast.AnnAssign, ast.AugAssign)):
+            invalidated_names.update(_mutated_record_roots(current.target))
+        elif isinstance(current, ast.Delete):
+            for target in current.targets:
+                invalidated_names.update(_mutated_record_roots(target))
+        elif (
+            isinstance(current, ast.Call)
+            and isinstance(current.func, ast.Attribute)
+            and current.func.attr in _RECORD_MUTATOR_METHODS
+            and isinstance(current.func.value, ast.Name)
+        ):
+            invalidated_names.add(current.func.value.id)
+        elif isinstance(current, ast.Call):
+            invalidated_names.update(
+                argument.id
+                for argument in (*current.args, *(keyword.value for keyword in current.keywords))
+                if isinstance(argument, ast.Name)
+            )
+        stack.extend(children(current))
+
+    changed = True
+    while changed:
+        changed = False
+        for alias, original in aliases.items():
+            if alias in invalidated_names and original not in invalidated_names:
+                invalidated_names.add(original)
+                changed = True
+            if original in invalidated_names and alias not in invalidated_names:
+                invalidated_names.add(alias)
+                changed = True
+
+    def original_name(name: str) -> str:
+        seen: set[str] = set()
+        while name in aliases and name not in seen:
+            seen.add(name)
+            name = aliases[name]
+        return name
+
+    intact_record_names = record_names - invalidated_names
+    if any(
+        isinstance(value, ast.Name) and original_name(value.id) in record_names & invalidated_names
+        for value in returned
+    ):
+        return False
+    return any(
+        _is_record_literal(value)
+        or (isinstance(value, ast.Name) and original_name(value.id) in intact_record_names)
+        for value in returned
+    )
+
+
+def _owned_nodes(node: ast.FunctionDef | ast.AsyncFunctionDef) -> list[ast.AST]:
+    owned: list[ast.AST] = []
+    stack: list[ast.AST] = list(node.body)
+    while stack:
+        current = stack.pop()
+        if isinstance(current, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef, ast.Lambda)):
+            continue
+        owned.append(current)
+        stack.extend(children(current))
+    return owned
+
+
+def _is_record_literal(node: ast.expr) -> bool:
+    if isinstance(node, ast.List):
+        return bool(node.elts) and all(_is_record_literal(element) for element in node.elts)
+    if isinstance(node, ast.ListComp):
+        return _is_record_literal(node.elt)
+    if not isinstance(node, ast.Dict):
+        return False
+    return bool(node.keys) and all(
+        isinstance(key, ast.Constant) and isinstance(key.value, str) for key in node.keys
+    )
+
+
+def _mutated_record_roots(target: ast.AST) -> set[str]:
+    while isinstance(target, ast.Subscript):
+        target = target.value
+    return {target.id} if isinstance(target, ast.Name) else set()

sarj_python_lint-0.80.8/src/sarj_python_lint/rules/_imports.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+import ast
+from collections.abc import Mapping
+from dataclasses import dataclass
+from types import MappingProxyType
+from typing import Self
+
+
+@dataclass(frozen=True, slots=True)
+class _ImportTarget:
+    module: str
+    symbol: str | None
+
+
+@dataclass(frozen=True, slots=True)
+class ImportIndex:
+    bindings: Mapping[str, _ImportTarget]
+    shadowed_names: frozenset[str]
+
+    @classmethod
+    def from_tree(cls, tree: ast.Module, *, module_scope_only: bool = False) -> Self:
+        candidates: dict[str, set[_ImportTarget]] = {}
+        statements = _module_import_statements(tree) if module_scope_only else tree.body
+        for statement in statements:
+            match statement:
+                case ast.Import(names=names):
+                    for alias in names:
+                        local = alias.asname or alias.name.partition(".")[0]
+                        module = alias.name if alias.asname else alias.name.partition(".")[0]
+                        candidates.setdefault(local, set()).add(_ImportTarget(module, None))
+                case ast.ImportFrom(module=str(module), names=names, level=0):
+                    for alias in names:
+                        if alias.name == "*":
+                            continue
+                        local = alias.asname or alias.name
+                        candidates.setdefault(local, set()).add(_ImportTarget(module, alias.name))
+                case _:
+                    pass
+
+        imported_names = frozenset(candidates)
+        non_import_bindings = (
+            _module_non_import_bindings(tree) if module_scope_only else _non_import_bindings(tree)
+        )
+        rebound = non_import_bindings & imported_names
+        bindings = {
+            local: next(iter(targets))
+            for local, targets in candidates.items()
+            if len(targets) == 1 and local not in rebound
+        }
+        return cls(MappingProxyType(bindings), frozenset(non_import_bindings))
+
+    def resolves(self, node: ast.expr, *, sources: frozenset[str], symbol: str) -> bool:
+        resolved = self._resolve(node)
+        return resolved is not None and resolved.module in sources and resolved.symbol == symbol
+
+    def resolved_symbol(self, node: ast.expr, *, sources: frozenset[str]) -> str | None:
+        resolved = self._resolve(node)
+        if resolved is None or resolved.module not in sources:
+            return None
+        return resolved.symbol
+
+    def builtin_is_unshadowed(self, name: str) -> bool:
+        return name not in self.shadowed_names and name not in self.bindings
+
+    def _resolve(self, node: ast.expr) -> _ImportTarget | None:
+        match node:
+            case ast.Name(id=local):
+                target = self.bindings.get(local)
+                return target if target is not None and target.symbol is not None else None
+            case ast.Attribute():
+                parts: list[str] = []
+                current: ast.expr = node
+                while isinstance(current, ast.Attribute):
+                    parts.append(current.attr)
+                    current = current.value
+                if not isinstance(current, ast.Name):
+                    return None
+                target = self.bindings.get(current.id)
+                if target is None or target.symbol is not None or not parts:
+                    return None
+                ordered = list(reversed(parts))
+                return _ImportTarget(".".join((target.module, *ordered[:-1])), ordered[-1])
+            case _:
+                return None
+
+
+def _non_import_bindings(tree: ast.Module) -> set[str]:
+    names: set[str] = set()
+    for node in ast.walk(tree):
+        match node:
+            case ast.Name(id=name, ctx=(ast.Store() | ast.Del())) | ast.arg(arg=name):
+                names.add(name)
+            case ast.FunctionDef() | ast.AsyncFunctionDef() | ast.ClassDef():
+                names.add(node.name)
+            case ast.alias():
+                # Imports are the candidate bindings, not shadows of themselves.
+                continue
+            case _:
+                pass
+    return names
+
+
+def _module_non_import_bindings(tree: ast.Module) -> set[str]:
+    names: set[str] = set()
+    for statement in tree.body:
+        match statement:
+            case ast.FunctionDef() | ast.AsyncFunctionDef() | ast.ClassDef():
+                names.add(statement.name)
+            case ast.Assign(targets=targets):
+                for target in targets:
+                    names.update(_target_names(target))
+            case ast.AnnAssign(target=target) | ast.AugAssign(target=target):
+                names.update(_target_names(target))
+            case ast.TypeAlias(name=ast.Name(id=name)):
+                names.add(name)
+            case ast.Import() | ast.ImportFrom():
+                continue
+            case _:
+                # Module control flow can still bind names in the module namespace.
+                _collect_module_bindings(statement, names)
+    return names
+
+
+def _target_names(node: ast.expr) -> set[str]:
+    if isinstance(node, ast.Name):
+        return {node.id}
+    if isinstance(node, (ast.Tuple, ast.List)):
+        return {name for element in node.elts for name in _target_names(element)}
+    return set()
+
+
+def _collect_module_bindings(node: ast.AST, names: set[str]) -> None:
+    match node:
+        case ast.FunctionDef() | ast.AsyncFunctionDef() | ast.ClassDef():
+            names.add(node.name)
+            return
+        case ast.ListComp() | ast.SetComp() | ast.GeneratorExp():
+            _collect_module_bindings(node.elt, names)
+            _collect_comprehension_bindings(node.generators, names)
+            return
+        case ast.DictComp():
+            _collect_module_bindings(node.key, names)
+            _collect_module_bindings(node.value, names)
+            _collect_comprehension_bindings(node.generators, names)
+            return
+        case ast.Lambda():
+            return
+        case ast.Name(id=name, ctx=(ast.Store() | ast.Del())):
+            names.add(name)
+        case _:
+            pass
+    for child in ast.iter_child_nodes(node):
+        _collect_module_bindings(child, names)
+
+
+def _collect_comprehension_bindings(generators: list[ast.comprehension], names: set[str]) -> None:
+    for generator in generators:
+        _collect_module_bindings(generator.iter, names)
+        for condition in generator.ifs:
+            _collect_module_bindings(condition, names)
+
+
+def _module_import_statements(tree: ast.Module) -> list[ast.stmt]:
+    statements = list(tree.body)
+    for statement in tree.body:
+        if not isinstance(statement, ast.If) or not _is_type_checking_guard(statement.test):
+            continue
+        statements.extend(
+            child for child in statement.body if isinstance(child, (ast.Import, ast.ImportFrom))
+        )
+    return statements
+
+
+def _is_type_checking_guard(node: ast.expr) -> bool:
+    return (isinstance(node, ast.Name) and node.id == "TYPE_CHECKING") or (
+        isinstance(node, ast.Attribute)
+        and isinstance(node.value, ast.Name)
+        and node.value.id in {"typing", "typing_extensions"}
+        and node.attr == "TYPE_CHECKING"
+    )

{sarj_python_lint-0.80.5 → sarj_python_lint-0.80.8}/src/sarj_python_lint/rules/_prose_budget.py

@@ -198,7 +198,7 @@ def _docstring_groups(tree: ast.Module) -> list[ProseGroup]:
         ):
             continue
         if isinstance(node, (ast.ClassDef, ast.FunctionDef, ast.AsyncFunctionDef)) and (
-            decorator_markers(node) & PROMPT_DECORATOR_MARKERS
+            _decorator_terminal_names(node) & PROMPT_DECORATOR_MARKERS
         ):
             continue
         if isinstance(node, ast.ClassDef) and _is_schema_class(node):
@@ -244,6 +244,17 @@ def _is_schema_class(node: ast.ClassDef) -> bool:
     return bool(bases & _SCHEMA_BASES or decorator_markers(node) & _SCHEMA_DECORATORS)
 
 
+def _decorator_terminal_names(node: ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef) -> frozenset[str]:
+    names: set[str] = set()
+    for decorator in node.decorator_list:
+        target = decorator.func if isinstance(decorator, ast.Call) else decorator
+        if isinstance(target, ast.Name):
+            names.add(target.id.casefold())
+        elif isinstance(target, ast.Attribute):
+            names.add(target.attr.casefold())
+    return frozenset(names)
+
+
 def _fully_typed(node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
     args = node.args
     parameters = (*args.posonlyargs, *args.args, *args.kwonlyargs)
@@ -270,21 +281,23 @@ def _typed_restatement_lines(
     docstring_line: int,
 ) -> tuple[int, ...]:
     annotations = {
-        arg.arg: _normalise_type(ast.unparse(arg.annotation))
+        arg.arg: _annotation_type(arg.annotation)
         for arg in (*node.args.posonlyargs, *node.args.args, *node.args.kwonlyargs)
         if arg.annotation is not None
     }
     if node.args.vararg is not None and node.args.vararg.annotation is not None:
-        annotations[f"*{node.args.vararg.arg}"] = _normalise_type(ast.unparse(node.args.vararg.annotation))
+        annotations[f"*{node.args.vararg.arg}"] = _annotation_type(node.args.vararg.annotation)
     if node.args.kwarg is not None and node.args.kwarg.annotation is not None:
-        annotations[f"**{node.args.kwarg.arg}"] = _normalise_type(ast.unparse(node.args.kwarg.annotation))
-    return_type = _normalise_type(ast.unparse(node.returns)) if node.returns is not None else ""
-    body_line_counts = _section_body_line_counts(doc)
+        annotations[f"**{node.args.kwarg.arg}"] = _annotation_type(node.args.kwarg.annotation)
+    return_type = _annotation_type(node.returns) if node.returns is not None else None
+    yield_type = _yielded_type(node.returns) if node.returns is not None else None
+    visible_doc = _without_literal_examples(doc)
+    body_line_counts = _section_body_line_counts(visible_doc)
 
     active: str | None = None
     active_header: int | None = None
     result: list[int] = []
-    for index, raw in enumerate(doc.splitlines()):
+    for index, raw in enumerate(visible_doc.splitlines()):
         if heading := _SECTION_HEADING_RE.match(raw):
             active = heading.group(1)
             active_header = index
@@ -297,20 +310,63 @@ def _typed_restatement_lines(
             continue
         if active in {"Args", "Arguments", "Parameters", "Params", "Keyword Args", "Keyword Arguments"}:
             match = _ARG_TYPE_ENTRY_RE.match(raw) or _NUMPY_ARG_TYPE_ENTRY_RE.match(raw)
-            if match is not None and _normalise_type(match.group(2)) == annotations.get(match.group(1)):
+            if match is not None and _documented_type(match.group(2)) == annotations.get(match.group(1)):
                 result.append(docstring_line + index)
         elif match := _RETURN_TYPE_ENTRY_RE.match(raw):
-            if _normalise_type(match.group(1)) == return_type:
+            expected = yield_type if active in {"Yields", "Yield"} else return_type
+            if expected is not None and _documented_type(match.group(1)) == expected:
                 result.append(docstring_line + index)
         elif (
             active_header is not None
             and body_line_counts.get(active_header) == 1
-            and _normalise_type(raw.strip()) == return_type
+            and (expected := yield_type if active in {"Yields", "Yield"} else return_type) is not None
+            and _documented_type(raw.strip()) == expected
         ):
             result.append(docstring_line + index)
     return tuple(result)
 
 
+def _without_literal_examples(doc: str) -> str:
+    visible: list[str] = []
+    fence: str | None = None
+    literal_indent: int | None = None
+    awaiting_literal_block = False
+    for raw in doc.splitlines():
+        stripped = raw.lstrip()
+        indent = len(raw) - len(stripped)
+        fence_marker = stripped[:3] if stripped.startswith(("```", "~~~")) else None
+        if fence is not None:
+            visible.append("")
+            if fence_marker == fence:
+                fence = None
+            continue
+        if fence_marker is not None:
+            fence = fence_marker
+            visible.append("")
+            continue
+        if stripped.startswith((">>>", "...")):
+            visible.append("")
+            continue
+        if literal_indent is not None:
+            if not stripped or indent > literal_indent:
+                visible.append("")
+                continue
+            literal_indent = None
+        if awaiting_literal_block:
+            if not stripped:
+                visible.append(raw)
+                continue
+            if indent > 0:
+                literal_indent = indent - 1
+                visible.append("")
+                awaiting_literal_block = False
+                continue
+            awaiting_literal_block = False
+        visible.append(raw)
+        awaiting_literal_block = stripped.endswith("::")
+    return "\n".join(visible)
+
+
 def _section_body_line_counts(doc: str) -> dict[int, int]:
     counts: dict[int, int] = {}
     active_header: int | None = None
@@ -325,5 +381,59 @@ def _section_body_line_counts(doc: str) -> dict[int, int]:
     return counts
 
 
+def _annotation_type(node: ast.expr) -> str:
+    if isinstance(node, ast.Constant) and isinstance(node.value, str):
+        parsed = _parse_type_expression(node.value)
+        return _normalise_type(ast.unparse(parsed)) if parsed is not None else node.value
+    return _normalise_type(ast.unparse(node))
+
+
+def _documented_type(value: str) -> str | None:
+    parsed = _parse_type_expression(value)
+    return None if parsed is None else _normalise_type(ast.unparse(parsed))
+
+
+def _parse_type_expression(value: str) -> ast.expr | None:
+    try:
+        parsed = ast.parse(value.strip(), mode="eval").body
+    except SyntaxError:
+        return None
+    unsafe = (
+        ast.Await,
+        ast.BoolOp,
+        ast.Call,
+        ast.Compare,
+        ast.DictComp,
+        ast.GeneratorExp,
+        ast.IfExp,
+        ast.Lambda,
+        ast.ListComp,
+        ast.NamedExpr,
+        ast.SetComp,
+        ast.Yield,
+        ast.YieldFrom,
+    )
+    if any(isinstance(part, unsafe) for part in ast.walk(parsed)):
+        return None
+    if any(isinstance(part, ast.BinOp) and not isinstance(part.op, ast.BitOr) for part in ast.walk(parsed)):
+        return None
+    return parsed
+
+
+def _yielded_type(node: ast.expr) -> str | None:
+    if isinstance(node, ast.Constant) and isinstance(node.value, str):
+        parsed = _parse_type_expression(node.value)
+        if parsed is None:
+            return None
+        node = parsed
+    if not isinstance(node, ast.Subscript):
+        return None
+    name = node.value.attr if isinstance(node.value, ast.Attribute) else node.value.id if isinstance(node.value, ast.Name) else ""
+    if name not in {"AsyncGenerator", "AsyncIterable", "AsyncIterator", "Generator", "Iterable", "Iterator"}:
+        return None
+    members = node.slice.elts if isinstance(node.slice, ast.Tuple) else (node.slice,)
+    return _annotation_type(members[0]) if members else None
+
+
 def _normalise_type(value: str) -> str:
-    return re.sub(r"\s+", "", value).removeprefix("typing.").removesuffix(",optional").casefold()
+    return re.sub(r"\s+", "", value).removeprefix("typing.").casefold()