Repetition

def values(self) -> collections.abc.Iterable[lintkit.Value[str]]:
    """Yield module-scope variable binding names.

    Yields:
        Variable identifiers with their declaration locations.

    """
    for node in super().nodes():
        if isinstance(node, ast.Name):
            yield lintkit.Value.from_python(node.id, node)

def nodes(
    self,
) -> collections.abc.Iterable[_types.GlobalDefinitionNode]:
    """Return declarations from module-level control flow.

    Returns:
        Iterable of declarations outside class and function bodies.

    """
    tree: ast.Module = self.getitem("ast")
    return _node.global_nodes(tree)

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]

def check(self, value: lintkit.Value[str]) -> bool:
    """Report identifiers containing the module name as complete words.

    Args:
        value:
            Identifier name to check.

    Returns:
        True when the module name is a non-exact, contiguous word sequence
        in the identifier.
    """
    module_name = self.file.resolve().stem  # pyright: ignore[reportAttributeAccessIssue]
    identifier = "_".join(
        word.casefold() for word in _split(self.kind, value)
    )
    return (
        module_name != identifier
        and f"_{module_name}_" in f"_{identifier}_"
    )

def message(self, value: lintkit.Value[str]) -> str:
    """Describe the repeated module name.

    Args:
        value:
            Identifier name that repeats the module name.

    Returns:
        Diagnostic message containing both names.
    """
    return (
        f"{self.kind.title()} '{value}' repeats module name "
        f"'{self.file.resolve().stem}'."  # pyright: ignore[reportAttributeAccessIssue]
    )

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

    Returns:
        Description of the identifier category checked by this rule.
    """
    return f"Avoid repeating module name in {self.kind}."

def nodes(self) -> collections.abc.Iterable[ast.ClassDef]:
    """Return class definition nodes in their existing loader order.

    Returns:
        Iterable of ``ast.ClassDef`` nodes.

    """
    return self.getitem("nodes_map")[ast.ClassDef]

def values(
    self,
) -> collections.abc.Iterable[lintkit.Value[typing.Any]]:
    """Wrap values from the configured AST nodes.

    Yields:
        Values extracted from the configured AST nodes.

    """
    for node in self.nodes():
        yield lintkit.Value.from_python(self.unpack(node), node)

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]

def check(self, value: lintkit.Value[str]) -> bool:
    """Report identifiers containing the module name as complete words.

    Args:
        value:
            Identifier name to check.

    Returns:
        True when the module name is a non-exact, contiguous word sequence
        in the identifier.
    """
    module_name = self.file.resolve().stem  # pyright: ignore[reportAttributeAccessIssue]
    identifier = "_".join(
        word.casefold() for word in _split(self.kind, value)
    )
    return (
        module_name != identifier
        and f"_{module_name}_" in f"_{identifier}_"
    )

def message(self, value: lintkit.Value[str]) -> str:
    """Describe the repeated module name.

    Args:
        value:
            Identifier name that repeats the module name.

    Returns:
        Diagnostic message containing both names.
    """
    return (
        f"{self.kind.title()} '{value}' repeats module name "
        f"'{self.file.resolve().stem}'."  # pyright: ignore[reportAttributeAccessIssue]
    )

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

    Returns:
        Description of the identifier category checked by this rule.
    """
    return f"Avoid repeating module name in {self.kind}."

def nodes(
    self,
) -> collections.abc.Iterable[_types.FunctionNode]:
    """Yield function definition nodes in their existing loader order.

    Returns:
        Synchronous definitions followed by asynchronous definitions.

    """
    return itertools.chain.from_iterable(
        self.getitem("nodes_map")[t]
        for t in [ast.FunctionDef, ast.AsyncFunctionDef]
    )

def values(
    self,
) -> collections.abc.Iterable[lintkit.Value[typing.Any]]:
    """Wrap values from the configured AST nodes.

    Yields:
        Values extracted from the configured AST nodes.

    """
    for node in self.nodes():
        yield lintkit.Value.from_python(self.unpack(node), node)

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]

def check(self, value: lintkit.Value[str]) -> bool:
    """Report identifiers containing the module name as complete words.

    Args:
        value:
            Identifier name to check.

    Returns:
        True when the module name is a non-exact, contiguous word sequence
        in the identifier.
    """
    module_name = self.file.resolve().stem  # pyright: ignore[reportAttributeAccessIssue]
    identifier = "_".join(
        word.casefold() for word in _split(self.kind, value)
    )
    return (
        module_name != identifier
        and f"_{module_name}_" in f"_{identifier}_"
    )

def message(self, value: lintkit.Value[str]) -> str:
    """Describe the repeated module name.

    Args:
        value:
            Identifier name that repeats the module name.

    Returns:
        Diagnostic message containing both names.
    """
    return (
        f"{self.kind.title()} '{value}' repeats module name "
        f"'{self.file.resolve().stem}'."  # pyright: ignore[reportAttributeAccessIssue]
    )

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

    Returns:
        Description of the identifier category checked by this rule.
    """
    return f"Avoid repeating module name in {self.kind}."

def values(
    self,
) -> collections.abc.Iterable[lintkit.Value[_Candidate]]:
    """Yield every declaration-word candidate with its total count.

    Yields:
        Every unique declaration-word pair with the word's module-wide
        occurrence count.

    """
    candidates = [
        candidate
        for node in super().nodes()
        for candidate in self._split_node(node)
    ]
    counts = collections.Counter(word for _, word in candidates)
    for node, word in candidates:
        name = node.id if isinstance(node, ast.Name) else node.name
        candidate = _Candidate(
            name=name,
            label=self._label(node),
            word=word,
            occurrences=counts[word],
        )
        yield lintkit.Value.from_python(candidate, node)

def check(self, value: lintkit.Value[_Candidate]) -> bool:
    """Report candidates meeting the configured occurrence minimum.

    Args:
        value:
            Declaration-word candidate with its module-wide count.

    Returns:
        Whether the candidate reaches the configured minimum.

    """
    return value.occurrences >= self.config(
        "minimum_same_name_occurrences", 2
    )

def message(self, value: lintkit.Value[_Candidate]) -> str:
    """Describe the module that should own the declaration.

    Args:
        value:
            Repeated declaration-word candidate.

    Returns:
        Diagnostic with the declaration kind, name, and module name.

    """
    return (
        f"{value.label} '{value.name}' should be placed under module "
        f"'{value.word}'."
    )

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

    Returns:
        Description of the module-grouping rule.

    """
    return "Group globals with shared name words under modules."

def nodes(
    self,
) -> collections.abc.Iterable[_types.GlobalDefinitionNode]:
    """Return declarations from module-level control flow.

    Returns:
        Iterable of declarations outside class and function bodies.

    """
    tree: ast.Module = self.getitem("ast")
    return _node.global_nodes(tree)

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]