scitex 2.0.0__py2.py3-none-any.whl → 2.1.0__py2.py3-none-any.whl

scitex/nn/__init__.py

@@ -2,13 +2,13 @@
 """Scitex nn module."""
 
 from ._AxiswiseDropout import AxiswiseDropout
-from ._BNet import BHead, BNet, BNet_config
-from ._BNet_Res import BHead, BNet, BNet_config
+from ._BNet import BHead as BHead_v1, BNet as BNet_v1, BNet_config as BNet_config_v1
+from ._BNet_Res import BHead as BHead_Res, BNet as BNet_Res, BNet_config as BNet_config_Res
 from ._ChannelGainChanger import ChannelGainChanger
 from ._DropoutChannels import DropoutChannels
 from ._Filters import BandPassFilter, BandStopFilter, BaseFilter1D, DifferentiableBandPassFilter, GaussianFilter, HighPassFilter, LowPassFilter
 from ._FreqGainChanger import FreqGainChanger
-from ._GaussianFilter import GaussianFilter
+# Removed duplicate GaussianFilter import - already imported from _Filters
 from ._Hilbert import Hilbert
 from ._MNet_1000 import MNet1000, MNet_1000, MNet_config, ReshapeLayer, SwapLayer
 from ._ModulationIndex import ModulationIndex
@@ -23,12 +23,12 @@ from ._Wavelet import Wavelet
 
 __all__ = [
     "AxiswiseDropout",
-    "BHead",
-    "BHead",
-    "BNet",
-    "BNet",
-    "BNet_config",
-    "BNet_config",
+    "BHead_v1",
+    "BHead_Res", 
+    "BNet_v1",
+    "BNet_Res",
+    "BNet_config_v1",
+    "BNet_config_Res",
     "BandPassFilter",
     "BandStopFilter",
     "BaseFilter1D",
@@ -37,7 +37,6 @@ __all__ = [
     "DropoutChannels",
     "FreqGainChanger",
     "GaussianFilter",
-    "GaussianFilter",
     "HighPassFilter",
     "Hilbert",
     "LowPassFilter",

scitex/path/__init__.py

@@ -10,15 +10,27 @@ 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 ._symlink import (
+    symlink,
+    is_symlink,
+    readlink,
+    resolve_symlinks,
+    create_relative_symlink,
+    unlink_symlink,
+    list_symlinks,
+    fix_broken_symlinks,
+)
 from ._this_path import get_this_path, this_path
 from ._version import find_latest, increment_version
 
 __all__ = [
     "clean",
+    "create_relative_symlink",
     "find_dir",
     "find_file",
     "find_git_root",
     "find_latest",
+    "fix_broken_symlinks",
     "get_data_path_from_a_package",
     "get_spath",
     "get_this_path",
@@ -26,8 +38,14 @@ __all__ = [
     "getsize",
     "increment_version",
     "increment_version",
+    "is_symlink",
+    "list_symlinks",
     "mk_spath",
+    "readlink",
+    "resolve_symlinks",
     "split",
+    "symlink",
     "this_path",
     "this_path",
+    "unlink_symlink",
 ]

scitex/path/_clean.py

@@ -27,6 +27,10 @@ def clean(path_string):
     str
         Normalized path string
     """
+    # Convert Path objects to strings to avoid AttributeError
+    if hasattr(path_string, '__fspath__'):  # Check if it's a path-like object
+        path_string = str(path_string)
+        
     if not path_string:
         return ""
     

scitex/path/_find.py

@@ -5,7 +5,7 @@
 #!./env/bin/python3
 # -*- coding: utf-8 -*-
 # Time-stamp: "2024-04-17 09:34:43"
-# Author: Yusuke Watanabe (ywata1989@gmail.com)
+# Author: Yusuke Watanabe (ywatanabe@scitex.ai)
 
 """
 This script does XYZ.
@@ -15,7 +15,6 @@ import fnmatch
 import os
 import sys
 
-import matplotlib.pyplot as plt
 import scitex
 
 
@@ -90,13 +89,19 @@ def _find(rootdir, type="f", exp=["*"]):
 
 
 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.gen.start(sys, plt)
+    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.session.start(sys, plt)
 
     # (YOUR AWESOME CODE)
 
     # Close
-    scitex.gen.close(CONFIG)
+    scitex.session.close(CONFIG)
 
 # EOF
 

scitex/path/_symlink.py

@@ -0,0 +1,348 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-09-16 15:11:33 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/path/_symlink.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = __file__
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+"""Symlink creation and management utilities for SciTeX."""
+
+# from scitex import logging
+from pathlib import Path
+from typing import Optional, Union
+
+from scitex import logging
+
+logger = logging.getLogger(__name__)
+
+
+def symlink(
+    src: Union[str, Path],
+    dst: Union[str, Path],
+    overwrite: bool = False,
+    target_is_directory: Optional[bool] = None,
+    relative: bool = False,
+) -> Path:
+    """
+    Create a symbolic link pointing to src named dst.
+
+    Args:
+        src: Source path (target of the symlink)
+        dst: Destination path (the symlink to create)
+        overwrite: If True, remove existing dst before creating symlink
+        target_is_directory: On Windows, specify if target is directory (auto-detected if None)
+        relative: If True, create relative symlink instead of absolute
+
+    Returns:
+        Path object of the created symlink
+
+    Raises:
+        FileExistsError: If dst exists and overwrite=False
+        FileNotFoundError: If src doesn't exist
+        OSError: If symlink creation fails
+
+    Examples:
+        >>> import scitex as stx
+        >>> # Create absolute symlink
+        >>> stx.path.symlink("/path/to/source", "/path/to/link")
+
+        >>> # Create relative symlink
+        >>> stx.path.symlink("../source", "link", relative=True)
+
+        >>> # Overwrite existing symlink
+        >>> stx.path.symlink("/path/to/new_source", "/path/to/link", overwrite=True)
+    """
+    src_path = Path(src)
+    dst_path = Path(dst)
+
+    # Note: We allow creating symlinks to non-existent targets
+    # This is valid in Unix/Linux and useful for testing
+
+    # Handle existing destination
+    if dst_path.exists() or dst_path.is_symlink():
+        if not overwrite:
+            raise FileExistsError(f"Destination already exists: {dst_path}")
+        else:
+            # Remove existing file/symlink
+            if dst_path.is_symlink():
+                dst_path.unlink()
+            elif dst_path.is_file():
+                dst_path.unlink()
+            elif dst_path.is_dir():
+                import shutil
+
+                shutil.rmtree(dst_path)
+            # logger.info(f"Removed existing destination: {dst_path}")
+
+    # Create parent directory if needed
+    dst_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Determine if target is directory (for Windows)
+    if target_is_directory is None and src_path.exists():
+        target_is_directory = src_path.is_dir()
+
+    # Create symlink
+    try:
+        if relative:
+            # Calculate relative path from dst to src
+            if src_path.is_absolute():
+                # src is absolute, calculate relative from dst
+                try:
+                    rel_path = os.path.relpath(src_path, dst_path.parent)
+                    src_for_link = Path(rel_path)
+                except ValueError:
+                    # Can't create relative path (e.g., different drives on Windows)
+                    logger.warning(
+                        f"Cannot create relative path from {dst_path} to {src_path}, using absolute"
+                    )
+                    src_for_link = src_path.absolute()
+            else:
+                # Both paths are relative, need to resolve them first
+                # to calculate the correct relative path
+                src_abs = src_path.resolve()
+                dst_parent_abs = dst_path.parent.resolve()
+                try:
+                    rel_path = os.path.relpath(src_abs, dst_parent_abs)
+                    src_for_link = Path(rel_path)
+                except ValueError:
+                    # Can't create relative path
+                    logger.warning(
+                        f"Cannot create relative path from {dst_path} to {src_path}"
+                    )
+                    src_for_link = src_path
+        else:
+            src_for_link = src_path.absolute()
+
+        dst_path.symlink_to(
+            src_for_link, target_is_directory=target_is_directory
+        )
+        logger.success(f"Created symlink: {dst_path} -> {src_for_link}")
+
+    except OSError as e:
+        logger.warn(
+            f"Failed to create symlink from {dst_path} to {src_for_link}: {str(e)}"
+        )
+
+        # raise OSError(
+        #     f"Failed to create symlink from {dst_path} to {src_for_link}: {e}"
+        # )
+
+    return dst_path
+
+
+def is_symlink(path: Union[str, Path]) -> bool:
+    """
+    Check if a path is a symbolic link.
+
+    Args:
+        path: Path to check
+
+    Returns:
+        True if path is a symlink, False otherwise
+
+    Examples:
+        >>> import scitex as stx
+        >>> stx.path.is_symlink("/path/to/link")
+        False
+    """
+    return Path(path).is_symlink()
+
+
+def readlink(path: Union[str, Path]) -> Path:
+    """
+    Return the path to which the symbolic link points.
+
+    Args:
+        path: Symlink path to read
+
+    Returns:
+        Path object pointing to the symlink target
+
+    Raises:
+        OSError: If path is not a symlink
+
+    Examples:
+        >>> import scitex as stx
+        >>> target = stx.path.readlink("/path/to/link")
+        >>> print(target)
+    """
+    path = Path(path)
+    if not path.is_symlink():
+        raise OSError(f"Path is not a symbolic link: {path}")
+
+    return Path(os.readlink(path))
+
+
+def resolve_symlinks(path: Union[str, Path]) -> Path:
+    """
+    Resolve all symbolic links in a path.
+
+    Args:
+        path: Path potentially containing symlinks
+
+    Returns:
+        Fully resolved absolute path
+
+    Examples:
+        >>> import scitex as stx
+        >>> resolved = stx.path.resolve_symlinks("/path/with/symlinks")
+        >>> print(resolved)
+    """
+    return Path(path).resolve()
+
+
+def create_relative_symlink(
+    src: Union[str, Path], dst: Union[str, Path], overwrite: bool = False
+) -> Path:
+    """
+    Create a relative symbolic link.
+
+    This is a convenience wrapper around symlink() with relative=True.
+
+    Args:
+        src: Source path (target of the symlink)
+        dst: Destination path (the symlink to create)
+        overwrite: If True, remove existing dst before creating symlink
+
+    Returns:
+        Path object of the created symlink
+
+    Examples:
+        >>> import scitex as stx
+        >>> # Create relative symlink from current dir to parent dir file
+        >>> stx.path.create_relative_symlink("../data/file.txt", "link_to_file")
+    """
+    return symlink(src, dst, overwrite=overwrite, relative=True)
+
+
+def unlink_symlink(path: Union[str, Path], missing_ok: bool = True) -> None:
+    """
+    Remove a symbolic link.
+
+    Args:
+        path: Symlink to remove
+        missing_ok: If True, don't raise error if symlink doesn't exist
+
+    Raises:
+        FileNotFoundError: If symlink doesn't exist and missing_ok=False
+        OSError: If path is not a symlink
+
+    Examples:
+        >>> import scitex as stx
+        >>> stx.path.unlink_symlink("/path/to/link")
+    """
+    path = Path(path)
+
+    if not path.exists() and not path.is_symlink():
+        if missing_ok:
+            return
+        raise FileNotFoundError(f"Symlink does not exist: {path}")
+
+    if not path.is_symlink():
+        raise OSError(f"Path is not a symbolic link: {path}")
+
+    path.unlink()
+    # logger.info(f"Removed symlink: {path}")
+
+
+def list_symlinks(
+    directory: Union[str, Path], recursive: bool = False
+) -> list[Path]:
+    """
+    List all symbolic links in a directory.
+
+    Args:
+        directory: Directory to search
+        recursive: If True, search recursively
+
+    Returns:
+        List of Path objects for all symlinks found
+
+    Examples:
+        >>> import scitex as stx
+        >>> symlinks = stx.path.list_symlinks("/path/to/dir")
+        >>> for link in symlinks:
+        ...     print(f"{link} -> {stx.path.readlink(link)}")
+    """
+    directory = Path(directory)
+    symlinks = []
+
+    if recursive:
+        for path in directory.rglob("*"):
+            if path.is_symlink():
+                symlinks.append(path)
+    else:
+        for path in directory.iterdir():
+            if path.is_symlink():
+                symlinks.append(path)
+
+    return symlinks
+
+
+def fix_broken_symlinks(
+    directory: Union[str, Path],
+    recursive: bool = False,
+    remove: bool = False,
+    new_target: Optional[Union[str, Path]] = None,
+) -> dict:
+    """
+    Find and optionally fix broken symbolic links.
+
+    Args:
+        directory: Directory to search
+        recursive: If True, search recursively
+        remove: If True, remove broken symlinks
+        new_target: If provided, repoint broken symlinks to this target
+
+    Returns:
+        Dictionary with 'found', 'fixed', and 'removed' lists of paths
+
+    Examples:
+        >>> import scitex as stx
+        >>> # Find broken symlinks
+        >>> result = stx.path.fix_broken_symlinks("/path/to/dir")
+        >>> print(f"Found {len(result['found'])} broken symlinks")
+
+        >>> # Remove broken symlinks
+        >>> result = stx.path.fix_broken_symlinks("/path/to/dir", remove=True)
+    """
+    directory = Path(directory)
+    result = {"found": [], "fixed": [], "removed": []}
+
+    symlinks = list_symlinks(directory, recursive=recursive)
+
+    for link in symlinks:
+        try:
+            # Check if target exists
+            target = Path(os.readlink(link))
+            if (
+                not link.parent.joinpath(target).exists()
+                and not target.is_absolute()
+            ):
+                # Relative link with non-existent target
+                result["found"].append(link)
+            elif target.is_absolute() and not target.exists():
+                # Absolute link with non-existent target
+                result["found"].append(link)
+        except (OSError, ValueError):
+            result["found"].append(link)
+
+    # Fix or remove broken symlinks
+    for link in result["found"]:
+        if remove:
+            link.unlink()
+            result["removed"].append(link)
+            # logger.info(f"Removed broken symlink: {link}")
+        elif new_target:
+            link.unlink()
+            symlink(new_target, link)
+            result["fixed"].append(link)
+            # logger.info(f"Fixed symlink: {link} -> {new_target}")
+
+    return result
+
+# EOF

scitex/path/_version.py

@@ -8,7 +8,7 @@ import re
 import sys
 from glob import glob
 
-import matplotlib.pyplot as plt
+# matplotlib imported in functions that need it
 
 
 # Functions
@@ -82,14 +82,15 @@ def increment_version(dirname, fname, ext, version_prefix="_v"):
 
 if __name__ == "__main__":
     import scitex
+    import matplotlib.pyplot as plt
 
     # Start
-    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.gen.start(sys, plt)
+    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.session.start(sys, plt)
 
     # (YOUR AWESOME CODE)
 
     # Close
-    scitex.gen.close(CONFIG)
+    scitex.session.close(CONFIG)
 
 # EOF
 

scitex/pd/__init__.py

@@ -5,6 +5,7 @@ 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 ._get_unique import get_unique
 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
@@ -23,6 +24,7 @@ __all__ = [
     "_find_pval_col",
     "force_df",
     "from_xyz",
+    "get_unique",
     "ignore_SettingWithCopyWarning",
     "ignore_setting_with_copy_warning",
     "melt_cols",

scitex/pd/_get_unique.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-09-18 18:42:11 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/pd/_get_unique.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = __file__
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+"""
+Extract unique values from DataFrame columns.
+"""
+
+from typing import Any, Optional
+
+import pandas as pd
+
+
+def get_unique(
+    df: pd.DataFrame,
+    column: str,
+    default: Optional[Any] = None,
+    raise_on_multiple: bool = False,
+) -> Any:
+    """Get value from column if it contains a unique value.
+
+    Args:
+        df: DataFrame to extract from
+        column: Column name to check
+        default: Default value if column doesn't exist or has multiple unique values
+        raise_on_multiple: If True, raise ValueError when multiple unique values exist
+
+    Returns:
+        The unique value if exactly one exists, otherwise default value
+
+    Examples:
+        >>> import pandas as pd
+        >>> df = pd.DataFrame({'patient_id': ['P01', 'P01', 'P01']})
+        >>> get_unique(df, 'patient_id')
+        'P01'
+
+        >>> df = pd.DataFrame({'patient_id': ['P01', 'P02']})
+        >>> get_unique(df, 'patient_id', default='Unknown')
+        'Unknown'
+
+        >>> # Raise error on multiple values
+        >>> get_unique(df, 'patient_id', raise_on_multiple=True)
+        ValueError: Column 'patient_id' has 2 unique values: ['P01', 'P02']
+    """
+    if column not in df.columns:
+        if raise_on_multiple:
+            raise KeyError(f"Column '{column}' not found in DataFrame")
+        return default
+
+    unique_values = df[column].unique()
+
+    if len(unique_values) == 1:
+        return unique_values[0]
+
+    if len(unique_values) > 1 and raise_on_multiple:
+        raise ValueError(
+            f"Column '{column}' has {len(unique_values)} unique values: "
+            f"{list(unique_values[:5])}"
+        )
+
+    return default
+
+
+if __name__ == "__main__":
+    # Test the function
+    import pandas as pd
+
+    # Test case 1: Unique value
+    df1 = pd.DataFrame({"patient_id": ["P01", "P01", "P01"]})
+    assert get_unique(df1, "patient_id") == "P01"
+    print("✓ Test 1 passed: Unique value extracted")
+
+    # Test case 2: Multiple values with default
+    df2 = pd.DataFrame({"patient_id": ["P01", "P02"]})
+    assert get_unique(df2, "patient_id", default="Unknown") == "Unknown"
+    print("✓ Test 2 passed: Default returned for multiple values")
+
+    # Test case 3: Missing column
+    assert get_unique(df1, "missing_col", default="N/A") == "N/A"
+    print("✓ Test 3 passed: Default returned for missing column")
+
+    # Test case 4: Raise on multiple
+    try:
+        get_unique(df2, "patient_id", raise_on_multiple=True)
+        assert False, "Should have raised ValueError"
+    except ValueError as e:
+        assert "has 2 unique values" in str(e)
+        print("✓ Test 4 passed: ValueError raised for multiple values")
+
+    print("\nAll tests passed!")
+
+# EOF