scitex 2.10.3__py3-none-any.whl → 2.13.0__py3-none-any.whl

scitex/path/_find.py

@@ -1,113 +1,90 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Time-stamp: "2024-11-02 19:53:58 (ywatanabe)"
-# File: ./scitex_repo/src/scitex/path/_find.py
-#!./env/bin/python3
-# -*- coding: utf-8 -*-
-# Time-stamp: "2024-04-17 09:34:43"
-# Author: Yusuke Watanabe (ywatanabe@scitex.ai)
-
-"""
-This script does XYZ.
-"""
+# Timestamp: "2026-01-08 02:00:00 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/path/_find.py
+
+"""File and directory finding utilities."""
 
 import fnmatch
-import os
-import sys
+from pathlib import Path
+from typing import List, Optional, Union
 
-import scitex
 
+def find_git_root() -> Path:
+    """Find the root directory of the current git repository.
 
-# Functions
-def find_git_root():
+    Returns
+    -------
+    Path
+        Path to the git repository root.
+    """
     import git
 
     repo = git.Repo(".", search_parent_directories=True)
-    return repo.working_tree_dir
+    return Path(repo.working_tree_dir)
 
 
-def find_dir(root_dir, exp):
+def find_dir(root_dir: Union[str, Path], exp: Union[str, List[str]]) -> List[Path]:
+    """Find directories matching pattern."""
     return _find(root_dir, type="d", exp=exp)
 
 
-def find_file(root_dir, exp):
+def find_file(root_dir: Union[str, Path], exp: Union[str, List[str]]) -> List[Path]:
+    """Find files matching pattern."""
     return _find(root_dir, type="f", exp=exp)
 
 
-def _find(rootdir, type="f", exp=["*"]):
-    """
-    Mimicks the Unix find command.
-
-    Example:
-        # rootdir =
-        # type = 'f'  # 'f' for files, 'd' for directories, None for both
-        # exp = '*.txt'  # Pattern to match, or None to match all
-        find('/path/to/search', "f", "*.txt")
+def _find(
+    rootdir: Union[str, Path],
+    type: Optional[str] = "f",
+    exp: Union[str, List[str]] = "*",
+) -> List[Path]:
+    """Mimics the Unix find command.
+
+    Parameters
+    ----------
+    rootdir : str or Path
+        Root directory to search in.
+    type : str, optional
+        'f' for files, 'd' for directories, None for both.
+    exp : str or list of str
+        Pattern(s) to match.
+
+    Returns
+    -------
+    list of Path
+        Matching paths.
+
+    Example
+    -------
+    >>> _find('/path/to/search', "f", "*.txt")
     """
+    rootdir = Path(rootdir)
     if isinstance(exp, str):
         exp = [exp]
 
+    exclude_keys = ["/lib/", "/env/", "/build/"]
     matches = []
-    for _exp in exp:
-        for root, dirs, files in os.walk(rootdir):
-            # Depending on the type, choose the list to iterate over
-            if type == "f":  # Files only
-                names = files
-            elif type == "d":  # Directories only
-                names = dirs
-            else:  # All entries
-                names = files + dirs
-
-            for name in names:
-                # Construct the full path
-                path = os.path.join(root, name)
-
-                # If an _exp is provided, use fnmatch to filter names
-                if _exp and not fnmatch.fnmatch(name, _exp):
-                    continue
-
-                # If type is set, ensure the type matches
-                if type == "f" and not os.path.isfile(path):
-                    continue
-                if type == "d" and not os.path.isdir(path):
-                    continue
-
-                exclude_keys = ["/lib/", "/env/", "/build/"]
-                if not any(ek in path for ek in exclude_keys):
-                    matches.append(path)
-
-                # for ek in exclude_keys:
-                #     if ek in path:
-                #         path = None
-                #         break
-
-                # if path is not None:
-                #     # Add the matching path to the results
-                #     matches.append(path)
-
-    return matches
-
-
-if __name__ == "__main__":
-    # Import matplotlib only when running as script
-    try:
-        import matplotlib.pyplot as plt
-    except ImportError:
-        plt = None
 
-    # Start
-    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.session.start(sys, plt)
+    for _exp in exp:
+        for path in rootdir.rglob("*"):
+            # Check type
+            if type == "f" and not path.is_file():
+                continue
+            if type == "d" and not path.is_dir():
+                continue
 
-    # (YOUR AWESOME CODE)
+            # Check pattern match
+            if _exp and not fnmatch.fnmatch(path.name, _exp):
+                continue
 
-    # Close
-    scitex.session.close(CONFIG)
+            # Check exclusions
+            path_str = str(path)
+            if any(ek in path_str for ek in exclude_keys):
+                continue
 
-# EOF
+            matches.append(path)
 
-"""
-/ssh:ywatanabe@444:/home/ywatanabe/proj/entrance/scitex/path/_find.py
-"""
+    return matches
 
 
 # EOF

scitex/path/_get_module_path.py

@@ -1,46 +1,48 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Time-stamp: "2024-11-14 07:39:32 (ywatanabe)"
-# File: ./scitex_repo/src/scitex/path/_get_module_path.py
+# Timestamp: "2026-01-08 02:00:00 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/path/_get_module_path.py
 
+"""Module path utilities."""
+
+import importlib.util
+from pathlib import Path
 
-def get_data_path_from_a_package(package_str, resource):
-    """
-    Get the path to a data file within a package.
 
-    This function finds the path to a data file within a package's data directory.
+def get_data_path_from_a_package(package_str: str, resource: str) -> Path:
+    """Get the path to a data file within a package.
 
-    Parameters:
-    -----------
+    Parameters
+    ----------
     package_str : str
         The name of the package as a string.
     resource : str
         The name of the resource file within the package's data directory.
 
-    Returns:
-    --------
-    str
+    Returns
+    -------
+    Path
         The full path to the resource file.
 
-    Raises:
-    -------
+    Raises
+    ------
     ImportError
         If the specified package cannot be found.
     FileNotFoundError
         If the resource file does not exist in the package's data directory.
     """
-    import importlib
-    import os
-    import sys
-
     spec = importlib.util.find_spec(package_str)
     if spec is None:
         raise ImportError(f"Package '{package_str}' not found")
 
-    data_dir = os.path.join(spec.origin.split("src")[0], "data")
-    resource_path = os.path.join(data_dir, resource)
+    origin = Path(spec.origin)
+    data_dir = origin.parents[0]
+    while "src" not in str(data_dir) and data_dir != data_dir.parent:
+        data_dir = data_dir.parent
+    data_dir = data_dir.parent / "data"
+
+    resource_path = data_dir / resource
 
-    if not os.path.exists(resource_path):
+    if not resource_path.exists():
         raise FileNotFoundError(
             f"Resource '{resource}' not found in package '{package_str}'"
         )

scitex/path/_get_spath.py

@@ -1,34 +1,13 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Time-stamp: "2024-11-02 20:51:29 (ywatanabe)"
-# File: ./scitex_repo/src/scitex/path/_get_spath.py
+# Timestamp: "2026-01-08 02:00:00 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/path/_get_spath.py
 
-import inspect
-import os
+"""Save path utilities - deprecated, use _mk_spath.py instead."""
 
-from ._split import split
+from ._mk_spath import mk_spath
 
-
-def get_spath(sfname=".", makedirs=False):
-    # if __IPYTHON__:
-    #     THIS_FILE = f'/tmp/{os.getenv("USER")}.py'
-    # else:
-    #     THIS_FILE = inspect.stack()[1].filename
-
-    THIS_FILE = inspect.stack()[1].filename
-    if "ipython" in __file__:  # for ipython
-        THIS_FILE = f"/tmp/{os.getenv('USER')}.py"
-
-    ## spath
-    fpath = __file__
-    fdir, fname, _ = split(fpath)
-    sdir = fdir + fname + "/"
-    spath = sdir + sfname
-
-    if makedirs:
-        os.makedirs(split(spath)[0], exist_ok=True)
-
-    return spath
+# Alias for backward compatibility
+get_spath = mk_spath
 
 
 # EOF

scitex/path/_getsize.py

@@ -1,18 +1,32 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Time-stamp: "2024-11-02 19:54:02 (ywatanabe)"
-# File: ./scitex_repo/src/scitex/path/_getsize.py
+# Timestamp: "2026-01-08 02:00:00 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/path/_getsize.py
 
-import os
+"""File size utilities."""
+
+from pathlib import Path
+from typing import Union
 
 import numpy as np
 
 
-def getsize(path):
-    if os.path.exists(path):
-        return os.path.getsize(path)
-    else:
-        return np.nan
+def getsize(path: Union[str, Path]) -> Union[int, float]:
+    """Get file size in bytes.
+
+    Parameters
+    ----------
+    path : str or Path
+        Path to file.
+
+    Returns
+    -------
+    int or float
+        File size in bytes, or np.nan if file doesn't exist.
+    """
+    path = Path(path)
+    if path.exists():
+        return path.stat().st_size
+    return np.nan
 
 
 # EOF

scitex/path/_increment_version.py

@@ -1,23 +1,28 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Time-stamp: "2024-11-02 19:45:32 (ywatanabe)"
-# File: ./scitex_repo/src/scitex/path/_increment_version.py
+# Timestamp: "2026-01-08 02:00:00 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/path/_increment_version.py
+
+"""File versioning utilities."""
 
-import os
 import re
-from glob import glob
+from pathlib import Path
+from typing import Union
 
 
-def increment_version(dirname, fname, ext, version_prefix="_v"):
-    """
-    Generate the next version of a filename based on existing versioned files.
+def increment_version(
+    dirname: Union[str, Path],
+    fname: str,
+    ext: str,
+    version_prefix: str = "_v",
+) -> Path:
+    """Generate the next version of a filename based on existing versioned files.
 
     This function searches for files in the given directory that match the pattern:
     {fname}{version_prefix}{number}{ext} and returns the path for the next version.
 
-    Parameters:
-    -----------
-    dirname : str
+    Parameters
+    ----------
+    dirname : str or Path
         The directory to search in and where the new file will be created.
     fname : str
         The base filename without version number or extension.
@@ -26,62 +31,50 @@ def increment_version(dirname, fname, ext, version_prefix="_v"):
     version_prefix : str, optional
         The prefix used before the version number. Default is '_v'.
 
-    Returns:
-    --------
-    str
+    Returns
+    -------
+    Path
         The full path for the next version of the file.
 
-    Example:
-    --------
+    Example
+    -------
     >>> increment_version('/path/to/dir', 'myfile', '.txt')
-    '/path/to/dir/myfile_v004.txt'
+    Path('/path/to/dir/myfile_v004.txt')
 
-    Notes:
-    ------
+    Notes
+    -----
     - If no existing versioned files are found, it starts with version 001.
     - The version number is always formatted with at least 3 digits.
     """
-    # Create a regex pattern to match the version number in the filename
+    dirname = Path(dirname)
+
     version_pattern = re.compile(
         rf"({re.escape(fname)}{re.escape(version_prefix)})(\d+)({re.escape(ext)})$"
     )
 
-    # Construct the glob pattern to find all files that match the pattern
-    glob_pattern = os.path.join(dirname, f"{fname}{version_prefix}*{ext}")
+    glob_pattern = f"{fname}{version_prefix}*{ext}"
+    files = list(dirname.glob(glob_pattern))
 
-    # Use glob to find all files that match the pattern
-    files = glob(glob_pattern)
-
-    # Initialize the highest version number
     highest_version = 0
     base, suffix = None, None
 
-    # Loop through the files to find the highest version number
     for file in files:
-        filename = os.path.basename(file)
-        match = version_pattern.search(filename)
+        match = version_pattern.search(file.name)
         if match:
             base, version_str, suffix = match.groups()
             version_num = int(version_str)
             if version_num > highest_version:
                 highest_version = version_num
 
-    # If no versioned files were found, use the provided filename and extension
     if base is None or suffix is None:
         base = f"{fname}{version_prefix}"
         suffix = ext
-        highest_version = 0  # No previous versions
+        highest_version = 0
 
-    # Increment the highest version number
     next_version_number = highest_version + 1
-
-    # Format the next version number with the same number of digits as the original
     next_version_str = f"{base}{next_version_number:03d}{suffix}"
 
-    # Combine the directory and new filename to create the full path
-    next_filepath = os.path.join(dirname, next_version_str)
-
-    return next_filepath
+    return dirname / next_version_str
 
 
 # EOF

scitex/path/_mk_spath.py

@@ -1,49 +1,46 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Time-stamp: "2024-11-02 20:59:46 (ywatanabe)"
-# File: ./scitex_repo/src/scitex/path/_mk_spath.py
+# Timestamp: "2026-01-08 02:00:00 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/path/_mk_spath.py
+
+"""Save path creation utilities."""
 
 import inspect
 import os
-
-from ._split import split
+from pathlib import Path
+from typing import Union
 
 
-def mk_spath(sfname, makedirs=False):
-    """
-    Create a save path based on the calling script's location.
+def mk_spath(sfname: Union[str, Path], makedirs: bool = False) -> Path:
+    """Create a save path based on the calling script's location.
 
-    Parameters:
-    -----------
-    sfname : str
+    Parameters
+    ----------
+    sfname : str or Path
         The name of the file to be saved.
     makedirs : bool, optional
-        If True, create the directory structure for the save path. Default is False.
+        If True, create the directory structure for the save path.
 
-    Returns:
-    --------
-    str
+    Returns
+    -------
+    Path
         The full save path for the file.
 
-    Example:
-    --------
-    >>> import scitex.io._path as path
-    >>> spath = path.mk_spath('output.txt', makedirs=True)
+    Example
+    -------
+    >>> spath = mk_spath('output.txt', makedirs=True)
     >>> print(spath)
-    '/path/to/current/script/output.txt'
+    Path('/path/to/current/script_out/output.txt')
     """
-    THIS_FILE = inspect.stack()[1].filename
-    if "ipython" in __file__:  # for ipython
-        THIS_FILE = f"/tmp/fake-{os.getenv('USER')}.py"
+    caller_file = inspect.stack()[1].filename
+    if "ipython" in caller_file.lower():
+        caller_file = f"/tmp/fake-{os.getenv('USER')}.py"
 
-    ## spath
-    fpath = __file__
-    fdir, fname, _ = split(fpath)
-    sdir = fdir + fname + "/"
-    spath = sdir + sfname
+    fpath = Path(caller_file)
+    sdir = fpath.parent / f"{fpath.stem}_out"
+    spath = sdir / sfname
 
     if makedirs:
-        os.makedirs(split(spath)[0], exist_ok=True)
+        spath.parent.mkdir(parents=True, exist_ok=True)
 
     return spath
 

scitex/path/_path.py

@@ -1,19 +1,12 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Time-stamp: "2024-11-02 20:46:35 (ywatanabe)"
-# File: ./scitex_repo/src/scitex/path/_path.py
+# Timestamp: "2026-01-08 02:00:00 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/path/_path.py
 
-import inspect
+"""Path utilities - deprecated, use _this_path.py instead."""
 
+from ._this_path import get_this_path, this_path
 
-def this_path(when_ipython="/tmp/fake.py"):
-    THIS_FILE = inspect.stack()[1].filename
-    if "ipython" in __file__:
-        THIS_FILE = when_ipython
-    return __file__
-
-
-get_this_path = this_path
+__all__ = ["this_path", "get_this_path"]
 
 
 # EOF

scitex/path/_split.py

@@ -1,23 +1,35 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Time-stamp: "2024-11-02 16:18:06 (ywatanabe)"
-# File: ./scitex_repo/src/scitex/path/_split.py
+# Timestamp: "2026-01-08 02:00:00 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/path/_split.py
 
-import os
+"""Path splitting utilities."""
 
+from pathlib import Path
+from typing import Tuple, Union
 
-def split(fpath):
-    """Split a file path to (1) the directory path, (2) the file name, and (3) the file extention
-    Example:
-        dirname, fname, ext = split('../data/01/day1/split_octave/2kHz_mat/tt8-2.mat')
-        print(dirname) # '../data/01/day1/split_octave/2kHz_mat/'
-        print(fname) # 'tt8-2'
-        print(ext) # '.mat'
+
+def split(fpath: Union[str, Path]) -> Tuple[Path, str, str]:
+    """Split a file path into directory, filename, and extension.
+
+    Parameters
+    ----------
+    fpath : str or Path
+        File path to split.
+
+    Returns
+    -------
+    tuple of (Path, str, str)
+        (directory, filename without extension, extension)
+
+    Example
+    -------
+    >>> dirname, fname, ext = split('../data/01/day1/tt8-2.mat')
+    >>> print(dirname)  # Path('../data/01/day1')
+    >>> print(fname)    # 'tt8-2'
+    >>> print(ext)      # '.mat'
     """
-    dirname = os.path.dirname(fpath) + "/"
-    base = os.path.basename(fpath)
-    fname, ext = os.path.splitext(base)
-    return dirname, fname, ext
+    path = Path(fpath)
+    return path.parent, path.stem, path.suffix
 
 
 # EOF

scitex/path/_this_path.py

@@ -1,19 +1,33 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Time-stamp: "2024-11-02 16:22:21 (ywatanabe)"
-# File: ./scitex_repo/src/scitex/path/_this_path.py
-#!/usr/bin/env python3
+# Timestamp: "2026-01-08 02:00:00 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/path/_this_path.py
+
+"""Get current file path utilities."""
 
 import inspect
+from pathlib import Path
+
 
+def this_path(ipython_fake_path: str = "/tmp/fake.py") -> Path:
+    """Get the path of the calling script.
 
-def this_path(ipython_fake_path="/tmp/fake.py"):
-    THIS_FILE = inspect.stack()[1].filename
-    if "ipython" in __file__:
-        THIS_FILE = ipython_fake_path
-    return __file__
+    Parameters
+    ----------
+    ipython_fake_path : str
+        Fake path to return when running in IPython.
+
+    Returns
+    -------
+    Path
+        Path to the calling script.
+    """
+    caller_file = inspect.stack()[1].filename
+    if "ipython" in caller_file.lower():
+        return Path(ipython_fake_path)
+    return Path(caller_file)
 
 
 get_this_path = this_path
 
+
 # EOF