scitex 2.0.0__py2.py3-none-any.whl

scitex/gen/_symlink.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-02 13:29:31 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/gen/_symlink.py
+
+import os
+from ..str._color_text import color_text
+
+
+def symlink(tgt, src, force=False):
+    """Create a symbolic link.
+
+    This function creates a symbolic link from the target to the source.
+    If the force parameter is True, it will remove any existing file at
+    the source path before creating the symlink.
+
+    Parameters
+    ----------
+    tgt : str
+        The target path (the file or directory to be linked to).
+    src : str
+        The source path (where the symbolic link will be created).
+    force : bool, optional
+        If True, remove the existing file at the src path before creating
+        the symlink (default is False).
+
+    Returns
+    -------
+    None
+
+    Raises
+    ------
+    OSError
+        If the symlink creation fails.
+
+    Example
+    -------
+    >>> symlink('/path/to/target', '/path/to/link')
+    >>> symlink('/path/to/target', '/path/to/existing_file', force=True)
+    """
+    if force:
+        try:
+            os.remove(src)
+        except FileNotFoundError:
+            pass
+
+    # Calculate the relative path from src to tgt
+    src_dir = os.path.dirname(src)
+    relative_tgt = os.path.relpath(tgt, src_dir)
+
+    os.symlink(relative_tgt, src)
+    print(color_text(f"\nSymlink was created: {src} -> {relative_tgt}\n", c="yellow"))
+
+
+# EOF

scitex/gen/_symlog.py

@@ -0,0 +1,27 @@
+#!./env/bin/python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-07-06 07:16:38 (ywatanabe)"
+# ./src/scitex/gen/_symlog.py
+
+import numpy as np
+
+
+def symlog(x, linthresh=1.0):
+    """
+    Apply a symmetric log transformation to the input data.
+
+    Parameters
+    ----------
+    x : array-like
+        Input data to be transformed.
+    linthresh : float, optional
+        Range within which the transformation is linear. Defaults to 1.0.
+
+    Returns
+    -------
+    array-like
+        Symmetrically transformed data.
+    """
+    sign_x = np.sign(x)
+    abs_x = np.abs(x)
+    return sign_x * (np.log1p(abs_x / linthresh))

scitex/gen/_tee.py

@@ -0,0 +1,238 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-02-15 00:02:15 (ywatanabe)"
+# File: ./src/scitex/gen/_tee.py
+
+THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/gen/_tee.py"
+
+"""
+Functionality:
+    * Redirects and logs standard output and error streams
+    * Filters progress bar outputs from stderr logging
+    * Maintains original stdout/stderr functionality while logging
+Input:
+    * System stdout/stderr streams
+    * Output file paths for logging
+Output:
+    * Wrapped stdout/stderr objects with logging capability
+    * Log files containing stdout and stderr outputs
+Prerequisites:
+    * Python 3.6+
+    * scitex package for path handling and colored printing
+"""
+
+"""Imports"""
+import os as _os
+import re
+import sys
+from typing import Any, List, TextIO
+
+from ..str._clean_path import clean_path
+from ..path import split
+from ..str._printc import printc
+
+"""Functions & Classes"""
+# class Tee(object):
+#     """Duplicates output streams to both console and log files.
+
+#     Example
+#     -------
+#     >>> import sys
+#     >>> sys.stdout = Tee(sys.stdout, "stdout.txt")
+#     >>> sys.stderr = Tee(sys.stderr, "stderr.txt")
+#     >>> print("Hello")  # Outputs to both console and stdout.txt
+#     >>> raise Exception("Error")  # Outputs to both console and stderr.txt
+#     """
+
+#     def __init__(self, sys_stdout_or_stderr, spath):
+#         """
+#         Parameters
+#         ----------
+#         stream : TextIO
+#             Original output stream (sys.stdout or sys.stderr)
+#         log_path : str
+#             Path to log file
+#         """
+#         self._files = [sys_stdout_or_stderr, open(spath, "w")]
+#         self._is_stderr = sys_stdout_or_stderr is sys.stderr
+
+#     def __getattr__(self, attr, *args):
+#         return self._wrap(attr, *args)
+
+#     def _wrap(self, attr, *args):
+#         def g(*a, **kw):
+#             for f in self._files:
+#                 if self._is_stderr and f is not sys.stderr:
+#                     # Filter tqdm lines from log file
+#                     msg = a[0] if a else ""
+#                     if not re.match(r"^[\s]*[0-9]+%.*\[A*$", msg):
+#                         res = getattr(f, attr, *args)(*a, **kw)
+#                 else:
+#                     res = getattr(f, attr, *args)(*a, **kw)
+#             return res
+
+#         return g
+
+
+class Tee:
+    def __init__(self, stream: TextIO, log_path: str) -> None:
+        self._stream = stream
+        try:
+            self._log_file = open(log_path, "w", buffering=1)  # Line buffering
+        except Exception as e:
+            printc(f"Failed to open log file {log_path}: {e}", c="red")
+            self._log_file = None
+        self._is_stderr = stream is sys.stderr
+
+    def write(self, data: Any) -> None:
+        self._stream.write(data)
+        if self._log_file is not None:
+            if self._is_stderr:
+                if isinstance(data, str) and not re.match(
+                    r"^[\s]*[0-9]+%.*\[A*$", data
+                ):
+                    self._log_file.write(data)
+                    self._log_file.flush()  # Ensure immediate write
+            else:
+                self._log_file.write(data)
+                self._log_file.flush()  # Ensure immediate write
+
+    def flush(self) -> None:
+        self._stream.flush()
+        if self._log_file is not None:
+            self._log_file.flush()
+
+    def isatty(self) -> bool:
+        return self._stream.isatty()
+
+    def fileno(self) -> int:
+        return self._stream.fileno()
+
+    @property
+    def buffer(self):
+        return self._stream.buffer
+
+    def close(self):
+        """Explicitly close the log file."""
+        if hasattr(self, "_log_file") and self._log_file is not None:
+            try:
+                self._log_file.flush()
+                self._log_file.close()
+                self._log_file = None  # Prevent double-close
+            except Exception:
+                pass
+
+    def __del__(self):
+        # Only attempt cleanup if Python is not shutting down
+        # This prevents "Exception ignored" errors during interpreter shutdown
+        if hasattr(self, "_log_file") and self._log_file is not None:
+            try:
+                # Check if the file object is still valid
+                if hasattr(self._log_file, "closed") and not self._log_file.closed:
+                    self.close()
+            except Exception:
+                # Silently ignore exceptions during cleanup
+                pass
+
+
+# class Tee:
+#     def __init__(self, stream: TextIO, log_path: str) -> None:
+#         self._files: List[TextIO] = [stream, open(log_path, "w")]
+#         self._is_stderr: bool = stream is sys.stderr
+#         self._stream = stream
+
+#     def write(self, data: Any) -> None:
+#         for file in self._files:
+#             if hasattr(file, 'write'):
+#                 if self._is_stderr and file is not sys.stderr:
+#                     if isinstance(data, str) and not re.match(r"^[\s]*[0-9]+%.*\[A*$", data):
+#                         file.write(data)
+#                 else:
+#                     file.write(data)
+
+#     def flush(self) -> None:
+#         for file in self._files:
+#             if hasattr(file, 'flush'):
+#                 file.flush()
+
+#     def isatty(self) -> bool:
+#         return getattr(self._stream, 'isatty', lambda: False)()
+
+#     def fileno(self) -> int:
+#         """Delegate fileno to original stream for IPython compatibility"""
+#         return self._stream.fileno()
+
+#     @property
+#     def buffer(self):
+#         return getattr(self._stream, 'buffer', self._stream)
+
+
+def tee(sys, sdir=None, verbose=True):
+    """Redirects stdout and stderr to both console and log files.
+
+    Example
+    -------
+    >>> import sys
+    >>> sys.stdout, sys.stderr = tee(sys)
+    >>> print("abc")  # stdout
+    >>> print(1 / 0)  # stderr
+
+    Parameters
+    ----------
+    sys_module : module
+        System module containing stdout and stderr
+    sdir : str, optional
+        Directory for log files
+    verbose : bool, default=True
+        Whether to print log file locations
+
+    Returns
+    -------
+    tuple[Any, Any]
+        Wrapped stdout and stderr objects
+    """
+    import inspect
+
+    ####################
+    ## Determine sdir
+    ## DO NOT MODIFY THIS
+    ####################
+    if sdir is None:
+        THIS_FILE = inspect.stack()[1].filename
+        if "ipython" in THIS_FILE:
+            THIS_FILE = f"/tmp/{_os.getenv('USER')}.py"
+        sdir = clean_path(_os.path.splitext(THIS_FILE)[0] + "_out")
+
+    sdir = _os.path.join(sdir, "logs/")
+    _os.makedirs(sdir, exist_ok=True)
+
+    spath_stdout = sdir + "stdout.log"
+    spath_stderr = sdir + "stderr.log"
+    sys_stdout = Tee(sys.stdout, spath_stdout)
+    sys_stderr = Tee(sys.stderr, spath_stderr)
+
+    if verbose:
+        message = f"Standard output/error are being logged at:\n\t{spath_stdout}\n\t{spath_stderr}"
+        printc(message)
+
+    return sys_stdout, sys_stderr
+
+
+main = tee
+
+if __name__ == "__main__":
+    # # Argument Parser
+    import matplotlib.pyplot as plt
+    import scitex
+
+    # import argparse
+    # parser = argparse.ArgumentParser(description='')
+    # parser.add_argument('--var', '-v', type=int, default=1, help='')
+    # parser.add_argument('--flag', '-f', action='store_true', default=False, help='')
+    # args = parser.parse_args()
+    # Main
+    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.gen.start(sys, plt, verbose=False)
+    main(sys, CONFIG["SDIR"])
+    scitex.gen.close(CONFIG, verbose=False, notify=False)
+
+# EOF

scitex/gen/_title2path.py

@@ -0,0 +1,60 @@
+#!./env/bin/python3
+# -*- coding: utf-8 -*-
+# Time-stamp: 2024-05-12 21:02:21 (7)
+# /sshx:ywatanabe@444:/home/ywatanabe/proj/scitex/src/scitex/gen/_title2spath.py
+
+
+def title2path(title):
+    """
+    Convert a title (string or dictionary) to a path-friendly string.
+
+    Parameters
+    ----------
+    title : str or dict
+        The input title to be converted.
+
+    Returns
+    -------
+    str
+        A path-friendly string derived from the input title.
+    """
+    if isinstance(title, dict):
+        from scitex.dict import to_str
+
+        title = to_str(title)
+
+    path = title
+
+    patterns = [":", ";", "=", "[", "]"]
+    for pattern in patterns:
+        path = path.replace(pattern, "")
+
+    path = path.replace("_-_", "-")
+    path = path.replace(" ", "_")
+
+    while "__" in path:
+        path = path.replace("__", "_")
+
+    return path.lower()
+
+
+# def title2path(title):
+#     if isinstance(title, dict):
+#         title = dict2str(title)
+
+#     path = title
+
+#     # Comma patterns
+#     patterns = [":", ";", "=", "[", "]"]
+#     for pp in patterns:
+#         path = path.replace(pp, "")
+
+#     # Exceptions
+#     path = path.replace("_-_", "-")
+#     path = path.replace(" ", "_")
+
+#     # Consective under scores
+#     for _ in range(10):
+#         path = path.replace("__", "_")
+
+#     return path.lower()

scitex/gen/_title_case.py

@@ -0,0 +1,88 @@
+#!./env/bin/python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-04-24 15:05:34"
+# Author: Yusuke Watanabe (ywata1989@gmail.com)
+
+
+"""
+This script does XYZ.
+"""
+
+
+"""
+Imports
+"""
+import sys
+
+import matplotlib.pyplot as plt
+
+
+"""
+Config
+"""
+# CONFIG = scitex.gen.load_configs()
+
+
+"""
+Functions & Classes
+"""
+
+
+def title_case(text):
+    """
+    Converts a string to title case while keeping certain prepositions, conjunctions, and articles in lowercase,
+    and ensuring words detected as potential acronyms (all uppercase) are fully capitalized.
+
+    Parameters:
+    - text (str): The text to convert to title case.
+
+    Returns:
+    - str: The converted text in title case with certain words in lowercase and potential acronyms fully capitalized.
+
+    Examples:
+    --------
+        print(title_case("welcome to the world of ai and using CPUs for gaming"))  # Welcome to the World of AI and Using CPUs for Gaming
+    """
+    # List of words to keep in lowercase
+    lowercase_words = [
+        "a",
+        "an",
+        "the",
+        "and",
+        "but",
+        "or",
+        "nor",
+        "at",
+        "by",
+        "to",
+        "in",
+        "with",
+        "of",
+        "on",
+    ]
+
+    words = text.split()
+    final_words = []
+    for word in words:
+        # Check if the word is fully in uppercase and more than one character, suggesting an acronym
+        if word.isupper() and len(word) > 1:
+            final_words.append(word)
+        elif word.lower() in lowercase_words:
+            final_words.append(word.lower())
+        else:
+            final_words.append(word.capitalize())
+    return " ".join(final_words)
+
+
+def main():
+    # Example usage:
+    text = "welcome to the world of ai and using CPUs for gaming"
+    print(title_case(text))
+
+
+if __name__ == "__main__":
+    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.gen.start(sys, plt, verbose=False)
+    main()
+    scitex.gen.close(CONFIG, verbose=False, notify=False)
+
+# EOF

scitex/gen/_to_even.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-25 23:40:12 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/gen/_to_even.py
+
+THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/gen/_to_even.py"
+
+
+def to_even(n):
+    """Convert a number to the nearest even number less than or equal to itself.
+
+    Parameters
+    ----------
+    n : int or float
+        The input number to be converted.
+
+    Returns
+    -------
+    int
+        The nearest even number less than or equal to the input.
+
+    Example
+    -------
+    >>> to_even(5)
+    4
+    >>> to_even(6)
+    6
+    >>> to_even(3.7)
+    2
+    >>> to_even(-2.3)
+    -4
+    >>> to_even(-0.1)
+    -2
+    """
+    import math
+    
+    # Handle integers directly to avoid float conversion issues with large numbers
+    # Note: bool is a subclass of int, so we need to exclude it
+    if isinstance(n, int) and not isinstance(n, bool):
+        if n % 2 == 0:
+            return int(n)  # Ensure we return int, not bool
+        else:
+            return int(n - 1)  # Ensure we return int, not bool
+    
+    # Handle special float values
+    if isinstance(n, float):
+        if math.isnan(n):
+            raise ValueError("Cannot convert NaN to even")
+        if math.isinf(n):
+            raise OverflowError("Cannot convert infinity to even")
+        # Python can actually convert sys.float_info.max to int, so we don't need this check
+        # Only infinity truly can't be converted
+    
+    # Try to handle custom objects with __int__ (but not float types)
+    if hasattr(n, '__int__') and not isinstance(n, (float, bool)):
+        try:
+            n_int = int(n)
+            if n_int % 2 == 0:
+                return int(n_int)
+            else:
+                return int(n_int - 1)
+        except:
+            pass
+    
+    # Check for string type explicitly - raise TypeError
+    if isinstance(n, str):
+        raise TypeError(f"must be real number, not {type(n).__name__}")
+    
+    # Convert to float for all other cases
+    try:
+        n_float = float(n)
+    except (TypeError, ValueError):
+        raise TypeError(f"must be real number, not {type(n).__name__}")
+    
+    # Use floor for float values
+    floored = int(math.floor(n_float))
+    
+    # If odd, subtract 1 to get the next lower even number
+    if floored % 2 != 0:
+        return int(floored - 1)  # Ensure we return int, not bool
+    return int(floored)  # Ensure we return int, not bool
+
+
+# EOF

scitex/gen/_to_odd.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-25 23:40:22 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/gen/_to_odd.py
+
+THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/gen/_to_odd.py"
+
+
+def to_odd(n):
+    """Convert a number to the nearest odd number less than or equal to itself.
+
+    Parameters
+    ----------
+    n : int or float
+        The input number to be converted.
+
+    Returns
+    -------
+    int
+        The nearest odd number less than or equal to the input.
+
+    Example
+    -------
+    >>> to_odd(6)
+    5
+    >>> to_odd(7)
+    7
+    >>> to_odd(5.8)
+    5
+    """
+    return int(n) - ((int(n) + 1) % 2)
+
+
+# EOF

scitex/gen/_to_rank.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-02 13:05:47 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/gen/_to_rank.py
+#!./env/bin/python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-08-29 22:10:06 (ywatanabe)"
+# ./src/scitex/gen/data_processing/_to_rank.py
+
+import torch
+
+# from .._converters import
+from ..decorators import torch_fn
+
+
+@torch_fn
+def to_rank(tensor, method="average"):
+    sorted_tensor, indices = torch.sort(tensor)
+    ranks = torch.empty_like(tensor)
+    ranks[indices] = (
+        torch.arange(len(tensor), dtype=tensor.dtype, device=tensor.device) + 1
+    )
+
+    if method == "average":
+        ranks = ranks.float()
+        ties = torch.nonzero(sorted_tensor[1:] == sorted_tensor[:-1])
+        for i in range(len(ties)):
+            start = ties[i]
+            end = start + 1
+            while (
+                end < len(sorted_tensor) and sorted_tensor[end] == sorted_tensor[start]
+            ):
+                end += 1
+            ranks[indices[start:end]] = ranks[indices[start:end]].mean()
+
+    return ranks
+
+
+# EOF

scitex/gen/_transpose.py

@@ -0,0 +1,37 @@
+#!./env/bin/python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-08-24 09:47:16 (ywatanabe)"
+# ./src/scitex/gen/_transpose.py
+
+from ..decorators import numpy_fn
+import numpy as np
+
+
+@numpy_fn
+def transpose(arr_like, src_dims, tgt_dims):
+    """
+    Transpose an array-like object based on source and target dimensions.
+
+    Parameters
+    ----------
+    arr_like : np.array
+        The input array to be transposed.
+    src_dims : np.array
+        List of dimension names in the source order.
+    tgt_dims : np.array
+        List of dimension names in the target order.
+
+    Returns
+    -------
+    np.array
+        The transposed array.
+
+    Raises
+    ------
+    AssertionError
+        If source and target dimensions don't contain the same elements.
+    """
+    assert set(src_dims) == set(
+        tgt_dims
+    ), "Source and target dimensions must contain the same elements"
+    return arr_like.transpose(*[np.where(src_dims == dim)[0][0] for dim in tgt_dims])