scitex 2.0.0__py2.py3-none-any.whl

scitex/path/__init__.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+"""Scitex path module."""
+
+from ._clean import clean
+from ._find import find_dir, find_file, find_git_root
+from ._get_module_path import get_data_path_from_a_package
+from ._get_spath import get_spath
+from ._getsize import getsize
+from ._increment_version import increment_version
+from ._mk_spath import mk_spath
+from ._path import get_this_path, this_path
+from ._split import split
+from ._this_path import get_this_path, this_path
+from ._version import find_latest, increment_version
+
+__all__ = [
+    "clean",
+    "find_dir",
+    "find_file",
+    "find_git_root",
+    "find_latest",
+    "get_data_path_from_a_package",
+    "get_spath",
+    "get_this_path",
+    "get_this_path",
+    "getsize",
+    "increment_version",
+    "increment_version",
+    "mk_spath",
+    "split",
+    "this_path",
+    "this_path",
+]

scitex/path/_clean.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2025-05-15 00:55:30 (ywatanabe)"
+# File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/path/_clean.py
+
+import os
+
+def clean(path_string):
+    """Cleans and normalizes a file system path string.
+
+    Example
+    -------
+    >>> clean('/home/user/./folder/../file.txt')
+    '/home/user/file.txt'
+    >>> clean('path/./to//file.txt')
+    'path/to/file.txt'
+    >>> clean('path with spaces')
+    'path_with_spaces'
+
+    Parameters
+    ----------
+    path_string : str
+        File path to clean
+
+    Returns
+    -------
+    str
+        Normalized path string
+    """
+    if not path_string:
+        return ""
+    
+    # Remember if path ends with a slash (indicating a directory)
+    is_directory = path_string.endswith("/")
+    
+    # Replace spaces with underscores
+    path_string = path_string.replace(" ", "_")
+    
+    # Use normpath to handle ../ and ./ references
+    cleaned_path = os.path.normpath(path_string)
+    
+    # Replace multiple slashes with single slash
+    while "//" in cleaned_path:
+        cleaned_path = cleaned_path.replace("//", "/")
+        
+    # Restore trailing slash if it was a directory
+    if is_directory and not cleaned_path.endswith("/"):
+        cleaned_path += "/"
+        
+    return cleaned_path
+
+# EOF

scitex/path/_find.py

@@ -0,0 +1,108 @@
+#!/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 (ywata1989@gmail.com)
+
+"""
+This script does XYZ.
+"""
+
+import fnmatch
+import os
+import sys
+
+import matplotlib.pyplot as plt
+import scitex
+
+
+# Functions
+def find_git_root():
+    import git
+
+    repo = git.Repo(".", search_parent_directories=True)
+    return repo.working_tree_dir
+
+
+def find_dir(root_dir, exp):
+    return _find(root_dir, type="d", exp=exp)
+
+
+def find_file(root_dir, exp):
+    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")
+    """
+    if isinstance(exp, str):
+        exp = [exp]
+
+    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__":
+    # Start
+    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.gen.start(sys, plt)
+
+    # (YOUR AWESOME CODE)
+
+    # Close
+    scitex.gen.close(CONFIG)
+
+# EOF
+
+"""
+/ssh:ywatanabe@444:/home/ywatanabe/proj/entrance/scitex/path/_find.py
+"""
+
+
+# EOF

scitex/path/_get_module_path.py

@@ -0,0 +1,51 @@
+#!/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
+
+
+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.
+
+    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
+        The full path to the resource file.
+
+    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)
+
+    if not os.path.exists(resource_path):
+        raise FileNotFoundError(
+            f"Resource '{resource}' not found in package '{package_str}'"
+        )
+
+    return resource_path
+
+
+# EOF

scitex/path/_get_spath.py

@@ -0,0 +1,35 @@
+#!/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
+
+import inspect
+import os
+
+from ._split import split
+
+
+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
+
+
+# EOF

scitex/path/_getsize.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-02 19:54:02 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/path/_getsize.py
+
+import os
+
+import numpy as np
+
+
+def getsize(path):
+    if os.path.exists(path):
+        return os.path.getsize(path)
+    else:
+        return np.nan
+
+
+# EOF

scitex/path/_increment_version.py

@@ -0,0 +1,87 @@
+#!/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
+
+import os
+import re
+from glob import glob
+
+
+def increment_version(dirname, fname, ext, version_prefix="_v"):
+    """
+    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
+        The directory to search in and where the new file will be created.
+    fname : str
+        The base filename without version number or extension.
+    ext : str
+        The file extension, including the dot (e.g., '.txt').
+    version_prefix : str, optional
+        The prefix used before the version number. Default is '_v'.
+
+    Returns:
+    --------
+    str
+        The full path for the next version of the file.
+
+    Example:
+    --------
+    >>> increment_version('/path/to/dir', 'myfile', '.txt')
+    '/path/to/dir/myfile_v004.txt'
+
+    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
+    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}")
+
+    # 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)
+        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
+
+    # 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
+
+
+# EOF

scitex/path/_mk_spath.py

@@ -0,0 +1,51 @@
+#!/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
+
+import inspect
+import os
+
+from ._split import split
+
+
+def mk_spath(sfname, makedirs=False):
+    """
+    Create a save path based on the calling script's location.
+
+    Parameters:
+    -----------
+    sfname : str
+        The name of the file to be saved.
+    makedirs : bool, optional
+        If True, create the directory structure for the save path. Default is False.
+
+    Returns:
+    --------
+    str
+        The full save path for the file.
+
+    Example:
+    --------
+    >>> import scitex.io._path as path
+    >>> spath = path.mk_spath('output.txt', makedirs=True)
+    >>> print(spath)
+    '/path/to/current/script/output.txt'
+    """
+    THIS_FILE = inspect.stack()[1].filename
+    if "ipython" in __file__:  # for ipython
+        THIS_FILE = f'/tmp/fake-{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
+
+
+# EOF

scitex/path/_path.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-02 20:46:35 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/path/_path.py
+
+import inspect
+
+
+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
+
+
+# EOF

scitex/path/_split.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-02 16:18:06 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/path/_split.py
+
+import os
+
+
+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'
+    """
+    dirname = os.path.dirname(fpath) + "/"
+    base = os.path.basename(fpath)
+    fname, ext = os.path.splitext(base)
+    return dirname, fname, ext
+
+
+# EOF

scitex/path/_this_path.py

@@ -0,0 +1,19 @@
+#!/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
+
+import inspect
+
+
+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__
+
+
+get_this_path = this_path
+
+# EOF

scitex/path/_version.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-02 20:48:24 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/path/_version.py
+
+import os
+import re
+import sys
+from glob import glob
+
+import matplotlib.pyplot as plt
+
+
+# Functions
+def find_latest(dirname, fname, ext, version_prefix="_v"):
+    version_pattern = re.compile(
+        rf"({re.escape(fname)}{re.escape(version_prefix)})(\d+)({re.escape(ext)})$"
+    )
+
+    glob_pattern = os.path.join(dirname, f"{fname}{version_prefix}*{ext}")
+    files = glob(glob_pattern)
+
+    highest_version = 0
+    latest_file = None
+
+    for file in files:
+        filename = os.path.basename(file)
+        match = version_pattern.search(filename)
+        if match:
+            version_num = int(match.group(2))
+            if version_num > highest_version:
+                highest_version = version_num
+                latest_file = file
+
+    return latest_file
+
+
+## Version
+def increment_version(dirname, fname, ext, version_prefix="_v"):
+    # Create a regex pattern to match the version number in the filename
+    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}")
+
+    # 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)
+        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
+
+    # 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
+
+
+if __name__ == "__main__":
+    import scitex
+
+    # Start
+    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.gen.start(sys, plt)
+
+    # (YOUR AWESOME CODE)
+
+    # Close
+    scitex.gen.close(CONFIG)
+
+# EOF
+
+"""
+/ssh:ywatanabe@444:/home/ywatanabe/proj/entrance/scitex/path/_version.py
+"""
+
+
+# EOF

scitex/pd/__init__.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+"""Scitex pd module."""
+
+from ._find_indi import find_indi
+from ._find_pval import find_pval, _find_pval_col
+from ._force_df import force_df
+from ._from_xyz import from_xyz
+from ._ignore_SettingWithCopyWarning import ignore_SettingWithCopyWarning, ignore_setting_with_copy_warning
+from ._melt_cols import melt_cols
+from ._merge_columns import merge_cols, merge_columns
+from ._mv import mv, mv_to_first, mv_to_last
+from ._replace import replace
+from ._round import round
+from ._slice import slice
+from ._sort import sort
+from ._to_numeric import to_numeric
+from ._to_xy import to_xy
+from ._to_xyz import to_xyz
+
+__all__ = [
+    "find_indi",
+    "find_pval",
+    "_find_pval_col",
+    "force_df",
+    "from_xyz",
+    "ignore_SettingWithCopyWarning",
+    "ignore_setting_with_copy_warning",
+    "melt_cols",
+    "merge_cols",
+    "merge_columns",
+    "mv",
+    "mv_to_first",
+    "mv_to_last",
+    "replace",
+    "round",
+    "slice",
+    "sort",
+    "to_numeric",
+    "to_xy",
+    "to_xyz",
+]