134 lines
4.6 KiB
Python
134 lines
4.6 KiB
Python
from typing import Dict, List
|
|
|
|
from .glob_group import GlobGroup, GlobPattern
|
|
|
|
__all__ = ["Directory"]
|
|
|
|
|
|
class Directory:
|
|
"""A file structure representation. Organized as Directory nodes that have lists of
|
|
their Directory children. Directories for a package are created by calling
|
|
:meth:`PackageImporter.file_structure`."""
|
|
|
|
def __init__(self, name: str, is_dir: bool):
|
|
self.name = name
|
|
self.is_dir = is_dir
|
|
self.children: Dict[str, Directory] = {}
|
|
|
|
def _get_dir(self, dirs: List[str]) -> "Directory":
|
|
"""Builds path of Directories if not yet built and returns last directory
|
|
in list.
|
|
|
|
Args:
|
|
dirs (List[str]): List of directory names that are treated like a path.
|
|
|
|
Returns:
|
|
:class:`Directory`: The last Directory specified in the dirs list.
|
|
"""
|
|
if len(dirs) == 0:
|
|
return self
|
|
dir_name = dirs[0]
|
|
if dir_name not in self.children:
|
|
self.children[dir_name] = Directory(dir_name, True)
|
|
return self.children[dir_name]._get_dir(dirs[1:])
|
|
|
|
def _add_file(self, file_path: str):
|
|
"""Adds a file to a Directory.
|
|
|
|
Args:
|
|
file_path (str): Path of file to add. Last element is added as a file while
|
|
other paths items are added as directories.
|
|
"""
|
|
*dirs, file = file_path.split("/")
|
|
dir = self._get_dir(dirs)
|
|
dir.children[file] = Directory(file, False)
|
|
|
|
def has_file(self, filename: str) -> bool:
|
|
"""Checks if a file is present in a :class:`Directory`.
|
|
|
|
Args:
|
|
filename (str): Path of file to search for.
|
|
Returns:
|
|
bool: If a :class:`Directory` contains the specified file.
|
|
"""
|
|
lineage = filename.split("/", maxsplit=1)
|
|
child = lineage[0]
|
|
grandchildren = lineage[1] if len(lineage) > 1 else None
|
|
if child in self.children.keys():
|
|
if grandchildren is None:
|
|
return True
|
|
else:
|
|
return self.children[child].has_file(grandchildren)
|
|
return False
|
|
|
|
def __str__(self):
|
|
str_list: List[str] = []
|
|
self._stringify_tree(str_list)
|
|
return "".join(str_list)
|
|
|
|
def _stringify_tree(
|
|
self, str_list: List[str], preamble: str = "", dir_ptr: str = "─── "
|
|
):
|
|
"""Recursive method to generate print-friendly version of a Directory."""
|
|
space = " "
|
|
branch = "│ "
|
|
tee = "├── "
|
|
last = "└── "
|
|
|
|
# add this directory's representation
|
|
str_list.append(f"{preamble}{dir_ptr}{self.name}\n")
|
|
|
|
# add directory's children representations
|
|
if dir_ptr == tee:
|
|
preamble = preamble + branch
|
|
else:
|
|
preamble = preamble + space
|
|
|
|
file_keys: List[str] = []
|
|
dir_keys: List[str] = []
|
|
for key, val in self.children.items():
|
|
if val.is_dir:
|
|
dir_keys.append(key)
|
|
else:
|
|
file_keys.append(key)
|
|
|
|
for index, key in enumerate(sorted(dir_keys)):
|
|
if (index == len(dir_keys) - 1) and len(file_keys) == 0:
|
|
self.children[key]._stringify_tree(str_list, preamble, last)
|
|
else:
|
|
self.children[key]._stringify_tree(str_list, preamble, tee)
|
|
for index, file in enumerate(sorted(file_keys)):
|
|
pointer = last if (index == len(file_keys) - 1) else tee
|
|
str_list.append(f"{preamble}{pointer}{file}\n")
|
|
|
|
|
|
def _create_directory_from_file_list(
|
|
filename: str,
|
|
file_list: List[str],
|
|
include: "GlobPattern" = "**",
|
|
exclude: "GlobPattern" = (),
|
|
) -> Directory:
|
|
"""Return a :class:`Directory` file structure representation created from a list of files.
|
|
|
|
Args:
|
|
filename (str): The name given to the top-level directory that will be the
|
|
relative root for all file paths found in the file_list.
|
|
|
|
file_list (List[str]): List of files to add to the top-level directory.
|
|
|
|
include (Union[List[str], str]): An optional pattern that limits what is included from the file_list to
|
|
files whose name matches the pattern.
|
|
|
|
exclude (Union[List[str], str]): An optional pattern that excludes files whose name match the pattern.
|
|
|
|
Returns:
|
|
:class:`Directory`: a :class:`Directory` file structure representation created from a list of files.
|
|
"""
|
|
glob_pattern = GlobGroup(include, exclude=exclude, separator="/")
|
|
|
|
top_dir = Directory(filename, True)
|
|
for file in file_list:
|
|
if glob_pattern.matches(file):
|
|
top_dir._add_file(file)
|
|
return top_dir
|