iker-python-common 1.0.69__tar.gz → 1.0.71__tar.gz

{iker_python_common-1.0.69 → iker_python_common-1.0.71}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iker-python-common
-Version: 1.0.69
+Version: 1.0.71
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13

iker_python_common-1.0.71/src/iker/common/utils/shutils.py

@@ -0,0 +1,320 @@
+import fnmatch
+import os
+import pathlib
+import shutil
+import sys
+from collections.abc import Generator
+from typing import Protocol
+
+from iker.common.utils.strutils import is_empty
+
+__all__ = [
+    "make_path",
+    "fn_suffix",
+    "fn_suffixes",
+    "fn_stem",
+    "path_depth",
+    "glob_match",
+    "scan_files",
+    "copy_files",
+    "run",
+    "execute",
+]
+
+
+def make_path(
+    path: str | os.PathLike[str] | None,
+    *,
+    expand: bool = False,
+    normalize: bool = False,
+    absolute: bool = False,
+    resolve: bool = False,
+    check_exists: bool = False,
+    check_is_dir: bool = False,
+    check_is_file: bool = False,
+) -> pathlib.Path | None:
+    """
+    Creates a ``pathlib.Path`` object from the given path string or path-like object, applying the specified
+    transformations and checks.
+
+    :param path: The path string or path-like object to convert to a ``pathlib.Path`` object.
+    :param expand: If ``True``, expands environment variables and user home directory in the path.
+    :param normalize: If ``True``, normalizes the path by collapsing redundant separators and up-level references.
+    :param absolute: If ``True``, converts the path to an absolute path.
+    :param resolve: If ``True``, resolves symbolic links and returns the canonical path.
+    :param check_exists: If ``True``, checks if the path exists and raises a ``FileNotFoundError`` if it does not.
+    :param check_is_dir: If ``True``, checks if the path is a directory and raises a ``NotADirectoryError`` if it is not.
+    :param check_is_file: If ``True``, checks if the path is a file and raises a ``FileNotFoundError`` if it is not.
+    :return: A ``pathlib.Path`` object representing the given path after applying the specified transformations and
+    checks, or ``None`` if the input path is ``None``.
+    """
+    if path is None:
+        return None
+    path = os.fspath(path)
+
+    if expand:
+        path = os.path.expandvars(path)
+        path = os.path.expanduser(path)
+    if normalize:
+        path = os.path.normpath(path)
+    if absolute:
+        path = os.path.abspath(path)
+    if resolve:
+        path = os.path.realpath(path)
+
+    path = pathlib.Path(path)
+
+    if check_exists and not path.exists():
+        raise FileNotFoundError(f"path does not exist '{path}'")
+    if check_is_dir and not path.is_dir():
+        raise NotADirectoryError(f"path is not a directory '{path}'")
+    if check_is_file and not path.is_file():
+        raise FileNotFoundError(f"path is not a file '{path}'")
+
+    return path
+
+
+if sys.version_info < (3, 14):
+    def fn_suffix(filename: str | os.PathLike[str] | None) -> str | None:
+        """
+        Extracts the filename suffix from the given filename or path.
+
+        :param filename: The specific filename or path.
+        :return: The filename suffix, including the leading dot (e.g., ".txt" for "file.txt"),
+        or ``None`` if the input filename is ``None``.
+        """
+        if (path := make_path(filename)) is not None:
+            _, suffix_name = os.path.splitext(path.name)
+            return suffix_name
+        return None
+else:
+    def fn_suffix(filename: str | os.PathLike[str] | None) -> str | None:
+        """
+        Extracts the filename suffix from the given filename or path.
+
+        :param filename: The specific filename or path.
+        :return: The filename suffix, including the leading dot (e.g., ".txt" for "file.txt"),
+        or ``None`` if the input filename is ``None``.
+        """
+        if (path := make_path(filename)) is not None:
+            return path.suffix
+        return None
+
+if sys.version_info < (3, 14):
+    def fn_suffixes(filename: str | os.PathLike[str] | None) -> list[str]:
+        """
+        Extracts all filename suffixes from the given filename or path.
+
+        :param filename: The specific filename or path.
+        :return: A list of filename suffixes, each including the leading dot (e.g., [".tar", ".gz"] for "archive.tar.gz").
+        """
+        if (path := make_path(filename)) is not None:
+            results = []
+            stem_name = path.name
+            while True:
+                stem_name, suffix_name = os.path.splitext(stem_name)
+                if is_empty(suffix_name):
+                    return list(reversed(results))
+                results.append(suffix_name)
+        return []
+else:
+    def fn_suffixes(filename: str | os.PathLike[str] | None) -> list[str]:
+        """
+        Extracts all filename suffixes from the given filename or path.
+
+        :param filename: The specific filename or path.
+        :return: A list of filename suffixes, each including the leading dot (e.g., [".tar", ".gz"] for "archive.tar.gz").
+        """
+        if (path := make_path(filename)) is not None:
+            return path.suffixes
+        return []
+
+if sys.version_info < (3, 14):
+    def fn_stem(filename: str | os.PathLike[str] | None, minimal: bool = False) -> str | None:
+        """
+        Extracts the filename stem from the given filename or path.
+
+        :param filename: The specific filename or path.
+        :param minimal: If ``True``, extracts the minimal (shortest) stem, otherwise the default stem.
+        :return: The filename stem.
+        """
+        if (path := make_path(filename)) is not None:
+            if not minimal:
+                stem_name, _ = os.path.splitext(path.name)
+                return stem_name
+            else:
+                stem_name = path.name
+                while True:
+                    stem_name, suffix_name = os.path.splitext(stem_name)
+                    if is_empty(suffix_name):
+                        return stem_name
+        return None
+else:
+    def fn_stem(filename: str | os.PathLike[str] | None, minimal: bool = False) -> str | None:
+        """
+        Extracts the filename stem from the given filename or path.
+
+        :param filename: The specific filename or path.
+        :param minimal: If ``True``, extracts the minimal (shortest) stem, otherwise the default stem.
+        :return: The filename stem.
+        """
+        if (path := make_path(filename)) is not None:
+            if not minimal:
+                return path.stem
+            else:
+                while True:
+                    if is_empty(path.suffix):
+                        return path.stem
+                    path = path.with_suffix("")
+        return None
+
+
+def path_depth(root: str | os.PathLike[str], child: str | os.PathLike[str]) -> int:
+    """
+    Returns the relative path depth from the given ``child`` to the ``root``.
+
+    :param root: The root path.
+    :param child: The child path.
+    :return: Relative depth, or -1 if ``child`` is not under ``root``.
+    """
+    root = make_path(root, expand=True, resolve=True)
+    child = make_path(child, expand=True, resolve=True)
+    if not child.is_relative_to(root):
+        return -1
+    return len(child.relative_to(root).parts)
+
+
+def glob_match(
+    names: list[str],
+    include_patterns: list[str] | None = None,
+    exclude_patterns: list[str] | None = None,
+) -> list[str]:
+    """
+    Applies the given inclusive and exclusive glob patterns to the given ``names`` and returns the filtered result.
+
+    :param names: Names to apply the glob patterns to.
+    :param include_patterns: Inclusive glob patterns.
+    :param exclude_patterns: Exclusive glob patterns.
+    :return: Filtered names matching the patterns.
+    """
+    ret = set()
+    for pat in (include_patterns or []):
+        ret.update(fnmatch.filter(names, pat))
+    if include_patterns is None or len(include_patterns) == 0:
+        ret.update(names)
+    for pat in (exclude_patterns or []):
+        ret.difference_update(fnmatch.filter(names, pat))
+    return list(ret)
+
+
+class CopyFuncProtocol(Protocol):
+    def __call__(self, src: str | os.PathLike[str], dst: str | os.PathLike[str], **kwargs) -> None: ...
+
+
+def scan_files(
+    path: str | os.PathLike[str],
+    *,
+    include_patterns: list[str] | None = None,
+    exclude_patterns: list[str] | None = None,
+    depth: int = 0,
+) -> Generator[pathlib.Path, None, None]:
+    """
+    Recursively scans the given ``path`` and returns a list of files whose names satisfy the given name patterns and the
+    relative depth of their folders to the given root path is not greater than the specified ``depth`` value.
+
+    :param path: The root path to scan.
+    :param include_patterns: Inclusive glob patterns applied to the filenames.
+    :param exclude_patterns: Exclusive glob patterns applied to the filenames.
+    :param depth: Maximum depth of the subdirectories included in the scan.
+    :return: A generator yielding the paths of the files matching the patterns.
+    """
+    path = make_path(path, expand=True)
+    if path.exists() and not path.is_dir():
+        if len(glob_match([path.name], include_patterns, exclude_patterns)) == 0:
+            return
+        yield path
+
+    for parent, dirs, filenames in path.walk():
+        if 0 < depth <= path_depth(path, parent):
+            continue
+        for filename in glob_match(filenames, include_patterns, exclude_patterns):
+            yield parent / filename
+
+
+def copy_files(
+    src: str | os.PathLike[str],
+    dst: str | os.PathLike[str],
+    *,
+    include_patterns: list[str] | None = None,
+    exclude_patterns: list[str] | None = None,
+    depth: int = 0,
+    follow_symlinks: bool = False,
+    ignore_dangling_symlinks: bool = False,
+    dirs_exist_ok: bool = False,
+    copy_func: CopyFuncProtocol = shutil.copy2
+):
+    """
+    Recursively copies the given source path to the destination path. Only copies the files whose names satisfy the
+    given name patterns and the relative depth of their folders to the given source path is not greater than the
+    specified ``depth`` value.
+
+    :param src: The source path or file.
+    :param dst: The destination path or file.
+    :param include_patterns: Inclusive glob patterns applied to the filenames.
+    :param exclude_patterns: Exclusive glob patterns applied to the filenames.
+    :param depth: Maximum depth of the subdirectories included in the scan.
+    :param follow_symlinks: If ``True``, create symbolic links for the symbolic links present in the source; otherwise,
+    make a physical copy.
+    :param ignore_dangling_symlinks: If ``True``, ignore errors if the file pointed by the symbolic link does not exist.
+    :param dirs_exist_ok: If ``True``, ignore errors if the destination directory and subdirectories exist.
+    :param copy_func: Copy function to use for copying files.
+    """
+    src = make_path(src, expand=True)
+    dst = make_path(dst, expand=True)
+    if not src.is_dir():
+        if len(glob_match([src.name], include_patterns, exclude_patterns)) == 0:
+            return
+        if not dst.exists():
+            dst.parent.mkdir(parents=True, exist_ok=True)
+        copy_func(src, dst, follow_symlinks=follow_symlinks)
+        return
+
+    def ignore_func(parent: str | os.PathLike[str], names: list[str]) -> set[str]:
+        parent = make_path(parent, expand=True)
+        filenames = list(filter(lambda x: not (parent / x).is_dir(), names))
+        ret = set(filenames)
+        if 0 < depth <= path_depth(src, parent):
+            return ret
+        ret.difference_update(glob_match(filenames, include_patterns, exclude_patterns))
+        return ret
+
+    shutil.copytree(src,
+                    dst,
+                    symlinks=follow_symlinks,
+                    ignore=ignore_func,
+                    ignore_dangling_symlinks=ignore_dangling_symlinks,
+                    dirs_exist_ok=dirs_exist_ok,
+                    copy_function=copy_func)
+
+
+def run(cmd: str) -> bool:
+    """
+    Runs the given command and returns the success status.
+
+    :param cmd: Command to run.
+    :return: ``True`` if the command has been successfully run, ``False`` otherwise.
+    """
+    return os.system(cmd) == 0
+
+
+def execute(cmd: str, strip: bool = True) -> str:
+    """
+    Executes the given command and returns contents collected from standard output.
+
+    :param cmd: Command to execute.
+    :param strip: If ``True``, the contents will be stripped.
+    :return: The content from standard output.
+    """
+    if strip:
+        return os.popen(cmd).read().strip()
+    return os.popen(cmd).read()

{iker_python_common-1.0.69 → iker_python_common-1.0.71}/src/iker_python_common.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iker-python-common
-Version: 1.0.69
+Version: 1.0.71
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13

{iker_python_common-1.0.69 → iker_python_common-1.0.71}/test/iker_tests/common/utils/csvutils_test.py

@@ -1,5 +1,6 @@
 import itertools
 import math
+import tempfile
 import unittest
 
 import ddt
@@ -179,6 +180,72 @@ class CSVTest(unittest.TestCase):
                         lines + lines + lines_no_header + lines_no_header):
             self.assertTrue(json_compare(a, e))
 
+    def test_lines__wrong_cols(self):
+        view = csv.view(
+            [
+                csv.column("dummy_str", loader=str, dumper=str, null_str=r"\N"),
+                csv.column("dummy_bool", loader=parse_bool, dumper=str, null_str=r"\N"),
+                csv.column("dummy_int", loader=int, dumper=str, null_str=r"\N"),
+                csv.column("dummy_float", loader=float, dumper=str, null_str=r"\N"),
+            ],
+        )
+
+        lines = [
+            ["dummy_str", "dummy_bool", "dummy_int", "dummy_float", "dummy_datetime", "dummy_params"],
+            ["foo", "True", "1", "1.0", "2020-01-01T00:00:00", ""],
+            ["bar", "False", "-1", "-1.0", "2020-01-01T00:00:00", "key_1=value_1;key_2;!key_3"],
+            ["baz", r"\N", "100", "inf", "2020-01-01T00:00:00", r"\N"],
+            ["", r"\N", "-100", "-inf", "2020-01-01T00:00:00", ""],
+            [r"\N", r"\N", "0", "nan", "2020-01-01T00:00:00", r"\N"],
+            [r"\N", r"\N", r"\N", r"\N", r"\N", r"\N"],
+        ]
+
+        with self.assertRaises(ValueError):
+            list(view.load_lines(lines, has_header=True))
+
+        data = [
+            ["foo", "True", "1", "1.0", "2020-01-01T00:00:00", ""],
+            ["bar", "False", "-1", "-1.0", "2020-01-01T00:00:00", "key_1=value_1;key_2;!key_3"],
+            ["baz", r"\N", "100", "inf", "2020-01-01T00:00:00", r"\N"],
+            ["", r"\N", "-100", "-inf", "2020-01-01T00:00:00", ""],
+            [r"\N", r"\N", "0", "nan", "2020-01-01T00:00:00", r"\N"],
+            [r"\N", r"\N", r"\N", r"\N", r"\N", r"\N"],
+        ]
+
+        with self.assertRaises(ValueError):
+            list(view.dump_lines(data, has_header=True))
+
+    def test_lines__wrong_col_name(self):
+        view = csv.view(
+            [
+                csv.column("another_dummy_str", loader=str, dumper=str, null_str=r"\N"),
+                csv.column("another_dummy_bool", loader=parse_bool, dumper=str, null_str=r"\N"),
+                csv.column("another_dummy_int", loader=int, dumper=str, null_str=r"\N"),
+                csv.column("another_dummy_float", loader=float, dumper=str, null_str=r"\N"),
+                csv.column("another_dummy_datetime",
+                           loader=lambda x: dt_to_ts(dt_parse_iso(x)),
+                           dumper=lambda x: dt_format_iso(dt_from_ts(x)),
+                           null_str=r"\N"),
+                csv.column("another_dummy_params",
+                           loader=lambda x: parse_params_string(x, delim=";", kv_delim="=", neg_prefix="!"),
+                           dumper=lambda x: make_params_string(x, delim=";", kv_delim="=", neg_prefix="!"),
+                           null_str=r"\N"),
+            ],
+        )
+
+        lines = [
+            ["dummy_str", "dummy_bool", "dummy_int", "dummy_float", "dummy_datetime", "dummy_params"],
+            ["foo", "True", "1", "1.0", "2020-01-01T00:00:00", ""],
+            ["bar", "False", "-1", "-1.0", "2020-01-01T00:00:00", "key_1=value_1;key_2;!key_3"],
+            ["baz", r"\N", "100", "inf", "2020-01-01T00:00:00", r"\N"],
+            ["", r"\N", "-100", "-inf", "2020-01-01T00:00:00", ""],
+            [r"\N", r"\N", "0", "nan", "2020-01-01T00:00:00", r"\N"],
+            [r"\N", r"\N", r"\N", r"\N", r"\N", r"\N"],
+        ]
+
+        with self.assertRaises(ValueError):
+            list(view.load_lines(lines, has_header=True))
+
     def test_file(self):
         view_csv = csv.view(
             [
@@ -236,3 +303,13 @@ class CSVTest(unittest.TestCase):
             self.assertTrue(json_compare(c, d))
             self.assertTrue(json_compare(t, d))
             self.assertTrue(json_compare(c, t))
+
+        with tempfile.NamedTemporaryFile() as fh:
+            view_csv.dump_file(data, fh.name, has_header=True, encoding="utf-8")
+            for a, e in zip(view_csv.load_file(fh.name, has_header=True, encoding="utf-8"), data):
+                self.assertTrue(json_compare(a, e))
+
+        with tempfile.NamedTemporaryFile() as fh:
+            view_tsv.dump_file(data, fh.name, has_header=True, encoding="utf-8")
+            for a, e in zip(view_tsv.load_file(fh.name, has_header=True, encoding="utf-8"), data):
+                self.assertTrue(json_compare(a, e))

{iker_python_common-1.0.69 → iker_python_common-1.0.71}/test/iker_tests/common/utils/shutils_test.py

@@ -5,10 +5,10 @@ import unittest
 
 import ddt
 
-from iker.common.utils.shutils import copy, listfile
-from iker.common.utils.shutils import expanded_path, norm_path, path_depth
-from iker.common.utils.shutils import extension, extensions, stem
+from iker.common.utils.shutils import copy_files, scan_files
+from iker.common.utils.shutils import fn_stem, fn_suffix, fn_suffixes
 from iker.common.utils.shutils import glob_match
+from iker.common.utils.shutils import make_path, path_depth
 from testenv import resources_directory
 
 work_dir = pathlib.Path.cwd
@@ -17,7 +17,7 @@ home_dir = pathlib.Path.home
 
 @ddt.ddt
 class ShUtilsTest(unittest.TestCase):
-    data_extension = [
+    data_fn_suffix = [
         (".", ""),
         ("..", ""),
         ("...", ""),
@@ -43,13 +43,44 @@ class ShUtilsTest(unittest.TestCase):
         ("s3://bucket/foo/bar/git.scrappy.ignored", ".ignored"),
     ]
 
-    @ddt.idata(data_extension)
+    @ddt.idata(data_fn_suffix)
     @ddt.unpack
-    def test_extension(self, data, expect):
-        self.assertEqual(expect, extension(data))
+    def test_fn_suffix(self, data, expect):
+        self.assertEqual(expect, fn_suffix(data))
 
-    data_stem = [
-        (".", "."),
+    data_fn_suffixes = [
+        (".", []),
+        ("..", []),
+        ("...", []),
+        (".ignored", []),
+        (".ignored.", ["."]),
+        (".git.ignored", [".ignored"]),
+        ("..git.ignored", [".ignored"]),
+        ("..git..ignored", [".", ".ignored"]),
+        ("git.ignored", [".ignored"]),
+        ("git.scrappy.ignored", [".scrappy", ".ignored"]),
+        ("~/git.scrappy.ignored", [".scrappy", ".ignored"]),
+        ("./git.scrappy.ignored", [".scrappy", ".ignored"]),
+        ("../git.scrappy.ignored", [".scrappy", ".ignored"]),
+        ("/~/git.scrappy.ignored", [".scrappy", ".ignored"]),
+        ("/./git.scrappy.ignored", [".scrappy", ".ignored"]),
+        ("/../git.scrappy.ignored", [".scrappy", ".ignored"]),
+        ("/foo/bar/git.scrappy.ignored", [".scrappy", ".ignored"]),
+        ("/foo/bar/~/git.scrappy.ignored", [".scrappy", ".ignored"]),
+        ("/foo/bar/./git.scrappy.ignored", [".scrappy", ".ignored"]),
+        ("/foo/bar/../git.scrappy.ignored", [".scrappy", ".ignored"]),
+        ("/foo/bar/git.scrappy.ignored..baz.", [".scrappy", ".ignored", ".", ".baz", "."]),
+        ("http://domain/foo/bar/git.scrappy.ignored", [".scrappy", ".ignored"]),
+        ("s3://bucket/foo/bar/git.scrappy.ignored", [".scrappy", ".ignored"]),
+    ]
+
+    @ddt.idata(data_fn_suffixes)
+    @ddt.unpack
+    def test_fn_suffixes(self, data, expect):
+        self.assertEqual(expect, fn_suffixes(data))
+
+    data_fn_stem = [
+        (".", ""),
         ("..", ".."),
         ("...", "..."),
         (".ignored", ".ignored"),
@@ -74,13 +105,13 @@ class ShUtilsTest(unittest.TestCase):
         ("s3://bucket/foo/bar/git.scrappy.ignored", "git.scrappy"),
     ]
 
-    @ddt.idata(data_stem)
+    @ddt.idata(data_fn_stem)
     @ddt.unpack
-    def test_stem(self, data, expect):
-        self.assertEqual(expect, stem(data))
+    def test_fn_stem(self, data, expect):
+        self.assertEqual(expect, fn_stem(data))
 
-    data_stem__minimal = [
-        (".", "."),
+    data_fn_stem__minimal = [
+        (".", ""),
         ("..", ".."),
         ("...", "..."),
         (".ignored", ".ignored"),
@@ -105,43 +136,12 @@ class ShUtilsTest(unittest.TestCase):
         ("s3://bucket/foo/bar/git.scrappy.ignored", "git"),
     ]
 
-    @ddt.idata(data_stem__minimal)
+    @ddt.idata(data_fn_stem__minimal)
     @ddt.unpack
-    def test_stem__minimal(self, data, expect):
-        self.assertEqual(expect, stem(data, minimal=True))
+    def test_fn_stem__minimal(self, data, expect):
+        self.assertEqual(expect, fn_stem(data, minimal=True))
 
-    data_extensions = [
-        (".", []),
-        ("..", []),
-        ("...", []),
-        (".ignored", []),
-        (".ignored.", ["."]),
-        (".git.ignored", [".ignored"]),
-        ("..git.ignored", [".ignored"]),
-        ("..git..ignored", [".ignored", "..ignored"]),
-        ("git.ignored", [".ignored"]),
-        ("git.scrappy.ignored", [".ignored", ".scrappy.ignored"]),
-        ("~/git.scrappy.ignored", [".ignored", ".scrappy.ignored"]),
-        ("./git.scrappy.ignored", [".ignored", ".scrappy.ignored"]),
-        ("../git.scrappy.ignored", [".ignored", ".scrappy.ignored"]),
-        ("/~/git.scrappy.ignored", [".ignored", ".scrappy.ignored"]),
-        ("/./git.scrappy.ignored", [".ignored", ".scrappy.ignored"]),
-        ("/../git.scrappy.ignored", [".ignored", ".scrappy.ignored"]),
-        ("/foo/bar/git.scrappy.ignored", [".ignored", ".scrappy.ignored"]),
-        ("/foo/bar/~/git.scrappy.ignored", [".ignored", ".scrappy.ignored"]),
-        ("/foo/bar/./git.scrappy.ignored", [".ignored", ".scrappy.ignored"]),
-        ("/foo/bar/../git.scrappy.ignored", [".ignored", ".scrappy.ignored"]),
-        ("/foo/bar/git.scrappy.ignored..baz.", [".", ".baz.", "..baz.", ".ignored..baz.", ".scrappy.ignored..baz."]),
-        ("http://domain/foo/bar/git.scrappy.ignored", [".ignored", ".scrappy.ignored"]),
-        ("s3://bucket/foo/bar/git.scrappy.ignored", [".ignored", ".scrappy.ignored"]),
-    ]
-
-    @ddt.idata(data_extensions)
-    @ddt.unpack
-    def test_extensions(self, data, expect):
-        self.assertEqual(expect, extensions(data))
-
-    data_expanded_path = [
+    data_make_path = [
         (".", f"{work_dir()}"),
         ("./", f"{work_dir()}"),
         ("./foo", f"{work_dir()}/foo"),
@@ -186,12 +186,22 @@ class ShUtilsTest(unittest.TestCase):
         ("${EMPTY_ENV_PARAM}/foo/../bar/..", f"/"),
     ]
 
-    @ddt.idata(data_expanded_path)
+    @ddt.idata(data_make_path)
     @ddt.unpack
-    def test_expanded_path(self, data, expect):
+    def test_make_path(self, data, expect):
         os.environ["DUMMY_ENV_PARAM"] = "dummy_parent"
         os.environ["EMPTY_ENV_PARAM"] = ""
-        self.assertEqual(norm_path(expect), norm_path(expanded_path(data)))
+
+        self.assertEqual(make_path(expect), make_path(expect, normalize=True))
+        self.assertEqual(make_path(expect), make_path(data, expand=True, normalize=True, absolute=True, resolve=True))
+
+        if not make_path(expect).exists():
+            with self.assertRaises(FileNotFoundError):
+                make_path(expect, check_exists=True)
+            with self.assertRaises(NotADirectoryError):
+                make_path(expect, check_is_dir=True)
+            with self.assertRaises(FileNotFoundError):
+                make_path(expect, check_is_file=True)
 
     data_path_depth = [
         (".", ".", 0),
@@ -272,10 +282,12 @@ class ShUtilsTest(unittest.TestCase):
     @ddt.idata(data_glob_match)
     @ddt.unpack
     def test_glob_match(self, names, include_patterns, exclude_patterns, expect):
-        self.assertSetEqual(set(map(norm_path, glob_match(names, include_patterns, exclude_patterns))),
-                            set(map(norm_path, expect)))
+        self.assertSetEqual(
+            set(map(lambda x: make_path(x, normalize=True), glob_match(names, include_patterns, exclude_patterns))),
+            set(map(lambda x: make_path(x, normalize=True), expect)),
+        )
 
-    data_listfile = [
+    data_scan_files = [
         (
             "unittest/shutils",
             [],
@@ -411,16 +423,18 @@ class ShUtilsTest(unittest.TestCase):
         ),
     ]
 
-    @ddt.idata(data_listfile)
+    @ddt.idata(data_scan_files)
     @ddt.unpack
-    def test_listfile(self, path, include_patterns, exclude_patterns, depth, expect):
-        self.assertSetEqual(set(map(norm_path, listfile(resources_directory / path,
-                                                        include_patterns=include_patterns,
-                                                        exclude_patterns=exclude_patterns,
-                                                        depth=depth))),
-                            set(map(norm_path, map(lambda x: resources_directory / x, expect))))
+    def test_scan_files(self, path, include_patterns, exclude_patterns, depth, expect):
+        self.assertSetEqual(
+            set(map(lambda x: make_path(x, normalize=True), scan_files(resources_directory / path,
+                                                                       include_patterns=include_patterns,
+                                                                       exclude_patterns=exclude_patterns,
+                                                                       depth=depth))),
+            set(map(lambda x: make_path(x, normalize=True), map(lambda x: resources_directory / x, expect))),
+        )
 
-    data_copy = [
+    data_copy_files = [
         (
             "unittest/shutils",
             "unittest/shutils",
@@ -568,16 +582,18 @@ class ShUtilsTest(unittest.TestCase):
         ),
     ]
 
-    @ddt.idata(data_copy)
+    @ddt.idata(data_copy_files)
     @ddt.unpack
-    def test_copy(self, src, dst, include_patterns, exclude_patterns, depth, expect):
+    def test_copy_files(self, src, dst, include_patterns, exclude_patterns, depth, expect):
         with tempfile.TemporaryDirectory() as temp_directory:
             temp_directory = pathlib.Path(temp_directory)
-            copy(resources_directory / src,
-                 temp_directory / dst,
-                 include_patterns=include_patterns,
-                 exclude_patterns=exclude_patterns,
-                 depth=depth)
+            copy_files(resources_directory / src,
+                       temp_directory / dst,
+                       include_patterns=include_patterns,
+                       exclude_patterns=exclude_patterns,
+                       depth=depth)
 
-            self.assertSetEqual(set(map(norm_path, listfile(temp_directory / dst))),
-                                set(map(norm_path, map(lambda x: temp_directory / x, expect))))
+            self.assertSetEqual(
+                set(map(lambda x: make_path(x, normalize=True), scan_files(temp_directory / dst))),
+                set(map(lambda x: make_path(x, normalize=True), map(lambda x: temp_directory / x, expect))),
+            )

{iker_python_common-1.0.69 → iker_python_common-1.0.71}/test/iker_tests/common/utils/typeutils_test.py

@@ -4,7 +4,7 @@ from typing import Dict, List, Optional, SupportsFloat, SupportsInt, Union
 
 import ddt
 
-from iker.common.utils.typeutils import is_identical_type, is_optional_type
+from iker.common.utils.typeutils import is_identical_type, is_optional_type, print_type
 
 
 class DummyClass(object):
@@ -309,6 +309,8 @@ class TypeUtilsTest(unittest.TestCase):
     @ddt.idata(data_is_identical_type)
     @ddt.unpack
     def test_is_identical_type(self, a, b, strict_optional, expect):
+        print_type(a)
+        print_type(b)
         self.assertEqual(is_identical_type(a, b, strict_optional=strict_optional), expect)
         self.assertEqual(is_identical_type(b, a, strict_optional=strict_optional), expect)
 
@@ -407,6 +409,8 @@ class TypeUtilsTest(unittest.TestCase):
     @ddt.idata(data_is_identical_type__variant)
     @ddt.unpack
     def test_is_identical_type__variant(self, a, b, covariant, contravariant, expect):
+        print_type(a)
+        print_type(b)
         self.assertEqual(is_identical_type(a,
                                            b,
                                            strict_optional=False,

iker_python_common-1.0.69/src/iker/common/utils/shutils.py

@@ -1,239 +0,0 @@
-import fnmatch
-import os
-import shutil
-from typing import Protocol
-
-from iker.common.utils.iterutils import last, last_or_none, tail_iter
-from iker.common.utils.strutils import is_empty
-
-__all__ = [
-    "extension",
-    "extensions",
-    "stem",
-    "expanded_path",
-    "norm_path",
-    "path_depth",
-    "glob_match",
-    "listfile",
-    "copy",
-    "run",
-    "execute",
-]
-
-
-def extension(filename: str | os.PathLike[str]) -> str:
-    """
-    Extracts the filename extension from the given filename or path.
-
-    :param filename: The specific filename or path.
-    :return: The filename extension, including the leading dot (e.g., ".txt").
-    """
-    _, result = os.path.splitext(os.path.basename(filename))
-    return result
-
-
-def stem(filename: str | os.PathLike[str], minimal: bool = False) -> str:
-    """
-    Extracts the filename stem from the given filename or path.
-
-    :param filename: The specific filename or path.
-    :param minimal: If ``True``, extracts the minimal (shortest) stem, otherwise the default stem.
-    :return: The filename stem.
-    """
-    base = os.path.basename(filename)
-    if not minimal:
-        result, _ = os.path.splitext(base)
-        return result
-    else:
-        maximal_extension = last_or_none(extensions(base))
-        if is_empty(maximal_extension):
-            return base
-        else:
-            return base[:-len(maximal_extension)]
-
-
-def extensions(filename: str | os.PathLike[str]) -> list[str]:
-    """
-    Extracts all filename extensions and compound extensions from the given filename or path.
-
-    :param filename: The specific filename or path.
-    :return: List of all extensions, ordered from shortest to longest, each including the leading dot.
-    """
-    base = os.path.basename(filename)
-    results = [""]
-    while True:
-        fn, ext = os.path.splitext(base)
-        base = fn
-        if is_empty(ext):
-            break
-        results.append(ext + last(results))
-    return list(tail_iter(results))
-
-
-def expanded_path(path: str | os.PathLike[str]) -> str:
-    """
-    Returns the absolute expanded path, expanding environment variables and the home tilde.
-
-    :param path: The given path.
-    :return: The absolute canonical path.
-    """
-    return os.path.abspath(os.path.expanduser(os.path.expandvars(path)))
-
-
-def norm_path(path: str | os.PathLike[str]) -> str:
-    """
-    Returns the normalized path, collapsing redundant separators and up-level references.
-
-    :param path: The given path.
-    :return: The normalized path.
-    """
-    _, path = os.path.splitdrive(os.path.normpath(path))
-    return path
-
-
-def path_depth(root: str | os.PathLike[str], child: str | os.PathLike[str]) -> int:
-    """
-    Returns the relative path depth from the given ``child`` to the ``root``.
-
-    :param root: The root path.
-    :param child: The child path.
-    :return: Relative depth, or -1 if ``child`` is not under ``root``.
-    """
-    root_expanded = expanded_path(root)
-    child_expanded = expanded_path(child)
-    if not child_expanded.startswith(root_expanded):
-        return -1
-    return child_expanded[len(root_expanded):].count(os.sep)
-
-
-def glob_match(
-    names: list[str],
-    include_patterns: list[str] | None = None,
-    exclude_patterns: list[str] | None = None,
-) -> list[str]:
-    """
-    Applies the given inclusive and exclusive glob patterns to the given ``names`` and returns the filtered result.
-
-    :param names: Names to apply the glob patterns to.
-    :param include_patterns: Inclusive glob patterns.
-    :param exclude_patterns: Exclusive glob patterns.
-    :return: Filtered names matching the patterns.
-    """
-    ret = set()
-    for pat in (include_patterns or []):
-        ret.update(fnmatch.filter(names, pat))
-    if include_patterns is None or len(include_patterns) == 0:
-        ret.update(names)
-    for pat in (exclude_patterns or []):
-        ret.difference_update(fnmatch.filter(names, pat))
-    return list(ret)
-
-
-class CopyFuncProtocol(Protocol):
-    def __call__(self, src: str | os.PathLike[str], dst: str | os.PathLike[str], **kwargs) -> None: ...
-
-
-def listfile(
-    path: str | os.PathLike[str],
-    *,
-    include_patterns: list[str] | None = None,
-    exclude_patterns: list[str] | None = None,
-    depth: int = 0,
-) -> list[str]:
-    """
-    Recursively scans the given ``path`` and returns a list of files whose names satisfy the given name patterns and the
-    relative depth of their folders to the given root path is not greater than the specified ``depth`` value.
-
-    :param path: The root path to scan.
-    :param include_patterns: Inclusive glob patterns applied to the filenames.
-    :param exclude_patterns: Exclusive glob patterns applied to the filenames.
-    :param depth: Maximum depth of the subdirectories included in the scan.
-    :return: List of file paths matching the criteria.
-    """
-    if os.path.exists(path) and not os.path.isdir(path):
-        if len(glob_match([os.path.basename(path)], include_patterns, exclude_patterns)) == 0:
-            return []
-        return [path]
-
-    ret = []
-    for parent, dirs, filenames in os.walk(path):
-        if 0 < depth <= path_depth(path, parent):
-            continue
-        for filename in glob_match(filenames, include_patterns, exclude_patterns):
-            ret.append(os.path.join(parent, filename))
-    return ret
-
-
-def copy(
-    src: str | os.PathLike[str],
-    dst: str | os.PathLike[str],
-    *,
-    include_patterns: list[str] | None = None,
-    exclude_patterns: list[str] | None = None,
-    depth: int = 0,
-    follow_symlinks: bool = False,
-    ignore_dangling_symlinks: bool = False,
-    dirs_exist_ok: bool = False,
-    copy_func: CopyFuncProtocol = shutil.copy2
-):
-    """
-    Recursively copies the given source path to the destination path. Only copies the files whose names satisfy the
-    given name patterns and the relative depth of their folders to the given source path is not greater than the
-    specified ``depth`` value.
-
-    :param src: The source path or file.
-    :param dst: The destination path or file.
-    :param include_patterns: Inclusive glob patterns applied to the filenames.
-    :param exclude_patterns: Exclusive glob patterns applied to the filenames.
-    :param depth: Maximum depth of the subdirectories included in the scan.
-    :param follow_symlinks: If ``True``, create symbolic links for the symbolic links present in the source; otherwise, make a physical copy.
-    :param ignore_dangling_symlinks: If ``True``, ignore errors if the file pointed by the symbolic link does not exist.
-    :param dirs_exist_ok: If ``True``, ignore errors if the destination directory and subdirectories exist.
-    :param copy_func: Copy function to use for copying files.
-    """
-    if not os.path.isdir(src):
-        if len(glob_match([os.path.basename(src)], include_patterns, exclude_patterns)) == 0:
-            return
-        if not os.path.exists(dst):
-            os.makedirs(os.path.dirname(dst), exist_ok=True)
-        copy_func(src, dst, follow_symlinks=follow_symlinks)
-        return
-
-    def ignore_func(parent, names):
-        filenames = list(filter(lambda x: not os.path.isdir(os.path.join(parent, x)), names))
-        ret = set(filenames)
-        if 0 < depth <= path_depth(src, parent):
-            return ret
-        ret.difference_update(glob_match(filenames, include_patterns, exclude_patterns))
-        return ret
-
-    shutil.copytree(src,
-                    dst,
-                    symlinks=follow_symlinks,
-                    ignore=ignore_func,
-                    ignore_dangling_symlinks=ignore_dangling_symlinks,
-                    dirs_exist_ok=dirs_exist_ok,
-                    copy_function=copy_func)
-
-
-def run(cmd: str) -> bool:
-    """
-    Runs the given command and returns the success status.
-
-    :param cmd: Command to run.
-    :return: ``True`` if the command has been successfully run, ``False`` otherwise.
-    """
-    return os.system(cmd) == 0
-
-
-def execute(cmd: str, strip: bool = True) -> str:
-    """
-    Executes the given command and returns contents collected from standard output.
-
-    :param cmd: Command to execute.
-    :param strip: If ``True``, the contents will be stripped.
-    :return: The content from standard output.
-    """
-    if strip:
-        return os.popen(cmd).read().strip()
-    return os.popen(cmd).read()