dependenpy ¤

def __bool__(self) -> bool:
    """Node as Boolean.

    Returns:
        Result of node.empty.
    """
    return bool(self.modules or self.packages)

def __contains__(self, item: Package | Module) -> bool:
    """Get result of _contains, cache it and return it.

    Parameters:
        item: A package or module.

    Returns:
        True if self contains item, False otherwise.
    """
    if item not in self._contains_cache:
        self._contains_cache[item] = self._contains(item)
    return self._contains_cache[item]

def __getitem__(self, item: str) -> Package | Module:
    """Return the corresponding Package or Module object.

    Parameters:
        item: Name of the package/module, dot-separated.

    Raises:
        KeyError: When the package or module cannot be found.

    Returns:
        The corresponding object.
    """
    depth = item.count(".") + 1
    parts = item.split(".", 1)
    for module in self.modules:
        if parts[0] == module.name and depth == 1:
            return module
    for package in self.packages:
        if parts[0] == package.name:
            if depth == 1:
                return package
            obj = package.get(parts[1])
            if obj:
                return obj
    raise KeyError(item)

def as_dict(self) -> dict:
    """Return the dependencies as a dictionary.

    Returns:
        Dictionary of dependencies.
    """
    return {
        "name": str(self),
        "modules": [module.as_dict() for module in self.modules],
        "packages": [package.as_dict() for package in self.packages],
    }

def as_graph(self, depth: int = 0) -> Graph:
    """Create a graph with self as node, cache it, return it.

    Parameters:
        depth: Depth of the graph.

    Returns:
        An instance of Graph.
    """
    if depth not in self._graph_cache:
        self._graph_cache[depth] = Graph(self, depth=depth)  # type: ignore[arg-type]
    return self._graph_cache[depth]

def as_matrix(self, depth: int = 0) -> Matrix:
    """Create a matrix with self as node, cache it, return it.

    Parameters:
        depth: Depth of the matrix.

    Returns:
        An instance of Matrix.
    """
    if depth not in self._matrix_cache:
        self._matrix_cache[depth] = Matrix(self, depth=depth)  # type: ignore[arg-type]
    return self._matrix_cache[depth]

def as_treemap(self) -> TreeMap:
    """Return the dependencies as a TreeMap.

    Returns:
        An instance of TreeMap.
    """
    if not self._treemap_cache:
        self._treemap_cache = TreeMap(self)
    return self._treemap_cache

def build_dependencies(self) -> None:
    """Recursively build the dependencies for sub-modules and sub-packages.

    Iterate on node's modules then packages and call their
    build_dependencies methods.
    """
    for module in self.modules:
        module.build_dependencies()
    for package in self.packages:
        package.build_dependencies()

def build_tree(self) -> None:
    """Build the Python packages tree."""
    for spec in self.specs:
        if spec.ismodule:
            self.modules.append(Module(spec.name, spec.path, dsm=self))
        else:
            self.packages.append(
                Package(
                    spec.name,
                    spec.path,
                    dsm=self,
                    limit_to=spec.limit_to,
                    build_tree=True,
                    build_dependencies=False,
                    enforce_init=self.enforce_init,
                ),
            )

def get(self, item: str) -> Package | Module:
    """Get item through `__getitem__` and cache the result.

    Parameters:
        item: Name of package or module.

    Returns:
        The corresponding object.
    """
    if item not in self._item_cache:
        try:
            obj = self.__getitem__(item)
        except KeyError:
            obj = None
        self._item_cache[item] = obj
    return self._item_cache[item]

def get_target(self, target: str) -> Package | Module:
    """Get the result of _get_target, cache it and return it.

    Parameters:
        target: Target to find.

    Returns:
        Package containing target or corresponding module.
    """
    if target not in self._target_cache:
        self._target_cache[target] = self._get_target(target)
    return self._target_cache[target]

def print(self, format: str | None = TEXT, output: IO = sys.stdout, **kwargs: Any) -> None:  # noqa: A002
    """Print the object in a file or on standard output by default.

    Parameters:
        format: Output format (csv, json or text).
        output: Descriptor to an opened file (default to standard output).
        **kwargs: Additional arguments.
    """
    if format is None:
        format = TEXT

    if format != TEXT:
        kwargs.pop("zero", "")

    if format == TEXT:
        print(self._to_text(**kwargs), file=output)
    elif format == CSV:
        print(self._to_csv(**kwargs), file=output)
    elif format == JSON:
        print(self._to_json(**kwargs), file=output)

def print_graph(
    self,
    format: str | None = None,  # noqa: A002
    output: IO = sys.stdout,
    depth: int = 0,
    **kwargs: Any,
) -> None:
    """Print the graph for self's nodes.

    Parameters:
        format: Output format (csv, json or text).
        output: File descriptor on which to write.
        depth: Depth of the graph.
        **kwargs: Additional keyword arguments passed to `graph.print`.
    """
    graph = self.as_graph(depth=depth)
    graph.print(format=format, output=output, **kwargs)

def print_matrix(
    self,
    format: str | None = None,  # noqa: A002
    output: IO = sys.stdout,
    depth: int = 0,
    **kwargs: Any,
) -> None:
    """Print the matrix for self's nodes.

    Parameters:
        format: Output format (csv, json or text).
        output: File descriptor on which to write.
        depth: Depth of the matrix.
        **kwargs: Additional keyword arguments passed to `matrix.print`.
    """
    matrix = self.as_matrix(depth=depth)
    matrix.print(format=format, output=output, **kwargs)

def print_treemap(self, format: str | None = None, output: IO = sys.stdout, **kwargs: Any) -> None:  # noqa: A002
    """Print the matrix for self's nodes.

    Parameters:
        format: Output format (csv, json or text).
        output: File descriptor on which to write.
        **kwargs: Additional keyword arguments passed to `treemap.print`.
    """
    treemap = self.as_treemap()
    treemap.print(format=format, output=output, **kwargs)

def go_from(self, vertex: Vertex) -> None:
    """Tell the edge to go out from this vertex.

    Parameters:
        vertex (Vertex): vertex to go from.
    """
    if self.vertex_out:
        self.vertex_out.edges_out.remove(self)
    self.vertex_out = vertex
    vertex.edges_out.add(self)

def go_in(self, vertex: Vertex) -> None:
    """Tell the edge to go into this vertex.

    Parameters:
        vertex (Vertex): vertex to go into.
    """
    if self.vertex_in:
        self.vertex_in.edges_in.remove(self)
    self.vertex_in = vertex
    vertex.edges_in.add(self)

def find(self, package: str, **kwargs: Any) -> PackageSpec | None:
    """Find a package using package finders.

    Return the first package found.

    Parameters:
        package: package to find.
        **kwargs: additional keyword arguments used by finders.

    Returns:
        Package spec or None.
    """
    for finder in self.finders:
        package_spec = finder.find(package, **kwargs)
        if package_spec:
            return package_spec
    return None

def print(self, format: str | None = TEXT, output: IO = sys.stdout, **kwargs: Any) -> None:  # noqa: A002
    """Print the object in a file or on standard output by default.

    Parameters:
        format: Output format (csv, json or text).
        output: Descriptor to an opened file (default to standard output).
        **kwargs: Additional arguments.
    """
    if format is None:
        format = TEXT

    if format != TEXT:
        kwargs.pop("zero", "")

    if format == TEXT:
        print(self._to_text(**kwargs), file=output)
    elif format == CSV:
        print(self._to_csv(**kwargs), file=output)
    elif format == JSON:
        print(self._to_json(**kwargs), file=output)

def find(self, package: str, **kwargs: Any) -> PackageSpec | None:  # noqa: ARG002
    """Find method.

    Parameters:
        package: package to find.
        **kwargs: additional keyword arguments.

    Returns:
        Package spec or None.
    """
    spec = find_spec(package)
    if spec is None:
        return None
    if "." in package:
        package, rest = package.split(".", 1)
        limit = [rest]
        spec = find_spec(package)
    else:
        limit = []
    if spec is not None:
        if spec.submodule_search_locations:
            path = spec.submodule_search_locations[0]
        elif spec.origin and spec.origin != "built-in":
            path = spec.origin
        else:
            return None
        return PackageSpec(spec.name, path, limit)
    return None

def get_data(
    self,
    packages: list[str],
    enforce_init: bool = True,  # noqa: FBT001,FBT002
    depth: int | None = None,
) -> archan.DSM:
    """Provide matrix data for internal dependencies in a set of packages.

    Parameters:
        packages: The list of packages to check for.
        enforce_init: Whether to assert presence of __init__.py files in directories.
        depth: The depth of the matrix to generate.

    Returns:
        Instance of archan DSM.
    """
    dsm = DependenpyDSM(*packages, enforce_init=enforce_init)
    if depth is None:
        depth = guess_depth(packages)
    matrix = dsm.as_matrix(depth=depth)
    return archan.DesignStructureMatrix(data=matrix.data, entities=matrix.keys)

def absolute_name(self, depth: int = 0) -> str:
    """Return the absolute name of the node.

    Concatenate names from root to self within depth.

    Parameters:
        depth: Maximum depth to go to.

    Returns:
        Absolute name of the node (until given depth is reached).
    """
    node: Package
    node, node_depth = self, self.depth  # type: ignore[assignment]
    if depth < 1:
        depth = node_depth
    while node_depth > depth and node.package is not None:
        node = node.package
        node_depth -= 1
    names = []
    while node is not None:
        names.append(node.name)
        node = node.package  # type: ignore[assignment]
    return ".".join(reversed(names))

def find(self, package: str, **kwargs: Any) -> PackageSpec | None:
    """Find method.

    Parameters:
        package: Package to find.
        **kwargs: Additional keyword arguments.

    Returns:
        Package spec or None.
    """
    if not exists(package):
        return None
    name, path = None, None
    enforce_init = kwargs.pop("enforce_init", True)
    if isdir(package):
        if isfile(join(package, "__init__.py")) or not enforce_init:
            name, path = basename(package), package
    elif isfile(package) and package.endswith(".py"):
        name, path = splitext(basename(package))[0], package
    if name and path:
        return PackageSpec(name, path)
    return None

@staticmethod
def cast(keys: list[str], data: list[list[int]]) -> Matrix:
    """Cast a set of keys and an array to a Matrix object.

    Arguments:
        keys: The matrix keys.
        data: The matrix data.

    Returns:
        A new matrix.
    """
    matrix = Matrix()
    matrix.keys = copy.deepcopy(keys)
    matrix.data = copy.deepcopy(data)
    return matrix

def print(self, format: str | None = TEXT, output: IO = sys.stdout, **kwargs: Any) -> None:  # noqa: A002
    """Print the object in a file or on standard output by default.

    Parameters:
        format: Output format (csv, json or text).
        output: Descriptor to an opened file (default to standard output).
        **kwargs: Additional arguments.
    """
    if format is None:
        format = TEXT

    if format != TEXT:
        kwargs.pop("zero", "")

    if format == TEXT:
        print(self._to_text(**kwargs), file=output)
    elif format == CSV:
        print(self._to_csv(**kwargs), file=output)
    elif format == JSON:
        print(self._to_json(**kwargs), file=output)