Depth

def values(self) -> collections.abc.Iterable[lintkit.Value[int]]:
    """Yield the subscript depth of every explicit type root.

    Yields:
        Maximum nested subscript depth for each explicit type root.

    """
    for root in super().nodes():
        yield lintkit.Value.from_python(_depth(root), root)

def check(self, value: lintkit.Value[int]) -> bool:
    """Report subscript depths above the configured maximum.

    Args:
        value:
            Maximum nested subscript depth in the type root.

    Returns:
        True when the type depth exceeds the configured maximum.

    """
    return value > self._max_depth()

def message(self, value: lintkit.Value[int]) -> str:
    """Describe a type root that exceeds the depth limit.

    Args:
        value:
            Maximum nested subscript depth in the type root.

    Returns:
        Diagnostic containing the actual and maximum type depths.

    """
    return (
        f"Type has depth {value}, which exceeds the maximum of "
        f"{self._max_depth()}."
    )

def description(self) -> str:
    """Return the public rule description.

    Returns:
        Description of the nested type depth limit.

    """
    return "Avoid deeply nested types."

def nodes(self) -> collections.abc.Iterable[ast.expr]:
    """Yield explicit type-expression roots in grouped AST order.

    Yields:
        Annotation, return, alias, and type-variable bound expressions.

    """
    maybe_annotated = itertools.chain.from_iterable(
        self.getitem("nodes_map")[t] for t in [ast.AnnAssign, ast.arg]
    )
    maybe_returns = itertools.chain.from_iterable(
        self.getitem("nodes_map")[t]
        for t in [ast.FunctionDef, ast.AsyncFunctionDef]
    )
    maybe_bound = self.getitem("nodes_map")[ast.TypeVar]
    maybe_value = self.getitem("nodes_map")[ast.TypeAlias]

    for field, nodes in zip(
        ("annotation", "returns", "bound", "value"),
        (maybe_annotated, maybe_returns, maybe_bound, maybe_value),
        strict=True,
    ):
        for node in nodes:
            if (value := getattr(node, field)) is not None:
                yield value

def unpack(self, node: ast.AST) -> typing.Any:
    """Extract the value from a node.

    Args:
        node:
            The AST node to extract the value from.

    Returns:
        The value loaded from the node.

    """
    return node.name  # pyright: ignore[reportAttributeAccessIssue]