|
|
|
import os
|
|
import os.path as osp
|
|
from pathlib import Path
|
|
|
|
from .misc import is_str
|
|
|
|
|
|
def is_filepath(x):
|
|
return is_str(x) or isinstance(x, Path)
|
|
|
|
|
|
def fopen(filepath, *args, **kwargs):
|
|
if is_str(filepath):
|
|
return open(filepath, *args, **kwargs)
|
|
elif isinstance(filepath, Path):
|
|
return filepath.open(*args, **kwargs)
|
|
raise ValueError('`filepath` should be a string or a Path')
|
|
|
|
|
|
def check_file_exist(filename, msg_tmpl='file "{}" does not exist'):
|
|
if not osp.isfile(filename):
|
|
raise FileNotFoundError(msg_tmpl.format(filename))
|
|
|
|
|
|
def mkdir_or_exist(dir_name, mode=0o777):
|
|
if dir_name == '':
|
|
return
|
|
dir_name = osp.expanduser(dir_name)
|
|
os.makedirs(dir_name, mode=mode, exist_ok=True)
|
|
|
|
|
|
def symlink(src, dst, overwrite=True, **kwargs):
|
|
if os.path.lexists(dst) and overwrite:
|
|
os.remove(dst)
|
|
os.symlink(src, dst, **kwargs)
|
|
|
|
|
|
def scandir(dir_path, suffix=None, recursive=False, case_sensitive=True):
|
|
"""Scan a directory to find the interested files.
|
|
|
|
Args:
|
|
dir_path (str | obj:`Path`): Path of the directory.
|
|
suffix (str | tuple(str), optional): File suffix that we are
|
|
interested in. Default: None.
|
|
recursive (bool, optional): If set to True, recursively scan the
|
|
directory. Default: False.
|
|
case_sensitive (bool, optional) : If set to False, ignore the case of
|
|
suffix. Default: True.
|
|
|
|
Returns:
|
|
A generator for all the interested files with relative paths.
|
|
"""
|
|
if isinstance(dir_path, (str, Path)):
|
|
dir_path = str(dir_path)
|
|
else:
|
|
raise TypeError('"dir_path" must be a string or Path object')
|
|
|
|
if (suffix is not None) and not isinstance(suffix, (str, tuple)):
|
|
raise TypeError('"suffix" must be a string or tuple of strings')
|
|
|
|
if suffix is not None and not case_sensitive:
|
|
suffix = suffix.lower() if isinstance(suffix, str) else tuple(
|
|
item.lower() for item in suffix)
|
|
|
|
root = dir_path
|
|
|
|
def _scandir(dir_path, suffix, recursive, case_sensitive):
|
|
for entry in os.scandir(dir_path):
|
|
if not entry.name.startswith('.') and entry.is_file():
|
|
rel_path = osp.relpath(entry.path, root)
|
|
_rel_path = rel_path if case_sensitive else rel_path.lower()
|
|
if suffix is None or _rel_path.endswith(suffix):
|
|
yield rel_path
|
|
elif recursive and os.path.isdir(entry.path):
|
|
|
|
yield from _scandir(entry.path, suffix, recursive,
|
|
case_sensitive)
|
|
|
|
return _scandir(dir_path, suffix, recursive, case_sensitive)
|
|
|
|
|
|
def find_vcs_root(path, markers=('.git', )):
|
|
"""Finds the root directory (including itself) of specified markers.
|
|
|
|
Args:
|
|
path (str): Path of directory or file.
|
|
markers (list[str], optional): List of file or directory names.
|
|
|
|
Returns:
|
|
The directory contained one of the markers or None if not found.
|
|
"""
|
|
if osp.isfile(path):
|
|
path = osp.dirname(path)
|
|
|
|
prev, cur = None, osp.abspath(osp.expanduser(path))
|
|
while cur != prev:
|
|
if any(osp.exists(osp.join(cur, marker)) for marker in markers):
|
|
return cur
|
|
prev, cur = cur, osp.split(cur)[0]
|
|
return None
|
|
|
