scitex 2.0.0__py2.py3-none-any.whl

scitex/tex/_to_vec.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2025-06-05 12:00:00 (ywatanabe)"
+# File: ./src/scitex/tex/_to_vec.py
+
+"""
+LaTeX vector notation with fallback mechanisms.
+
+Functionality:
+    - Convert strings to LaTeX vector notation with automatic fallback
+    - Handle LaTeX rendering failures gracefully
+Input:
+    String representation of vector
+Output:
+    LaTeX vector notation with fallback support
+Prerequisites:
+    scitex.str._latex_fallback
+"""
+
+try:
+    from ..str._latex_fallback import safe_latex_render, latex_fallback_decorator
+    FALLBACK_AVAILABLE = True
+except ImportError:
+    FALLBACK_AVAILABLE = False
+    def latex_fallback_decorator(fallback_strategy="auto", preserve_math=True):
+        def decorator(func):
+            return func
+        return decorator
+    
+    def safe_latex_render(text, fallback_strategy="auto", preserve_math=True):
+        return text
+
+
+@latex_fallback_decorator(fallback_strategy="auto", preserve_math=True)
+def to_vec(v_str, enable_fallback=True, fallback_strategy="auto"):
+    r"""
+    Convert a string to LaTeX vector notation with automatic fallback.
+
+    Parameters
+    ----------
+    v_str : str
+        String representation of the vector
+    enable_fallback : bool, optional
+        Whether to enable LaTeX fallback mechanisms, by default True
+    fallback_strategy : str, optional
+        Fallback strategy: "auto", "mathtext", "unicode", "plain", by default "auto"
+
+    Returns
+    -------
+    str
+        LaTeX representation of the vector with automatic fallback
+
+    Examples
+    --------
+    >>> vector = to_vec("AB")
+    >>> print(vector)  # LaTeX: \overrightarrow{\mathrm{AB}}
+    
+    >>> vector = to_vec("AB")  # Falls back to unicode if LaTeX fails
+    >>> print(vector)  # Unicode: A⃗B or AB⃗
+    
+    Notes
+    -----
+    If LaTeX rendering fails, this function automatically falls back to:
+    - mathtext: Uses matplotlib's built-in math rendering
+    - unicode: Uses Unicode vector symbols (⃗)
+    - plain: Returns plain text with "vec()" notation
+    """
+    if not v_str:
+        return ""
+    
+    # Create LaTeX vector notation
+    latex_vector = f"\\overrightarrow{{\\mathrm{{{v_str}}}}}"
+    
+    if enable_fallback and FALLBACK_AVAILABLE:
+        # Custom fallback handling for vectors
+        if fallback_strategy == "auto":
+            # Try mathtext first, then unicode
+            try:
+                mathtext_result = safe_latex_render(f"${latex_vector}$", "mathtext")
+                return mathtext_result
+            except Exception:
+                # Fall back to unicode vector notation
+                return f"{v_str}⃗"  # Unicode combining right arrow above
+        elif fallback_strategy == "unicode":
+            return f"{v_str}⃗"  # Unicode combining right arrow above
+        elif fallback_strategy == "plain":
+            return f"vec({v_str})"
+        else:
+            return safe_latex_render(f"${latex_vector}$", fallback_strategy)
+    else:
+        return latex_vector
+
+
+def safe_to_vec(v_str, fallback_strategy="auto"):
+    """
+    Safe version of to_vec with explicit fallback control.
+    
+    Parameters
+    ----------
+    v_str : str
+        String representation of the vector
+    fallback_strategy : str, optional
+        Explicit fallback strategy: "auto", "mathtext", "unicode", "plain"
+        
+    Returns
+    -------
+    str
+        Vector notation with specified fallback behavior
+    """
+    return to_vec(v_str, enable_fallback=True, fallback_strategy=fallback_strategy)
+
+
+# Backward compatibility
+vector_notation = to_vec
+
+# EOF

scitex/torch/__init__.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+"""Scitex torch module."""
+
+from ._apply_to import apply_to
+from ._nan_funcs import nanargmax, nanargmin, nancumprod, nancumsum, nanmax, nanmin, nanprod, nanstd, nanvar
+
+__all__ = [
+    "apply_to",
+    "nanargmax",
+    "nanargmin",
+    "nancumprod",
+    "nancumsum",
+    "nanmax",
+    "nanmin",
+    "nanprod",
+    "nanstd",
+    "nanvar",
+]

scitex/torch/_apply_to.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-03-31 08:11:45 (ywatanabe)"
+
+import torch
+
+
+def apply_to(fn, x, dim):
+    """
+    Example:
+    x = torch.randn(2, 3, 4)
+    fn = sum
+    apply_to(fn, x, 1).shape # (2, 1, 4)
+    """
+    if dim != -1:
+        dims = list(range(x.dim()))
+        dims[-1], dims[dim] = dims[dim], dims[-1]
+        x = x.permute(*dims)
+
+    # Flatten the tensor along the time dimension
+    shape = x.shape
+    x = x.reshape(-1, shape[-1])
+
+    # Apply the function to each slice along the time dimension
+    applied = torch.stack([fn(x_i) for x_i in torch.unbind(x, dim=0)], dim=0)
+
+    # Reshape the tensor to its original shape (with the time dimension at the end)
+    applied = applied.reshape(*shape[:-1], -1)
+
+    # Permute back to the original dimension order if necessary
+    if dim != -1:
+        applied = applied.permute(*dims)
+
+    return applied

scitex/torch/_nan_funcs.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-10-28 19:38:19 (ywatanabe)"
+# /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/torch/_nan_funcs.py
+
+import torch as _torch
+
+
+# https://github.com/pytorch/pytorch/issues/61474
+def nanmax(tensor, dim=None, keepdim=False):
+    min_value = _torch.finfo(tensor.dtype).min
+    if dim is None:
+        output = tensor.nan_to_num(min_value).max()
+    else:
+        output = tensor.nan_to_num(min_value).max(dim=dim, keepdim=keepdim)
+    return output
+
+
+def nanmin(tensor, dim=None, keepdim=False):
+    max_value = _torch.finfo(tensor.dtype).max
+    if dim is None:
+        output = tensor.nan_to_num(max_value).min()
+    else:
+        output = tensor.nan_to_num(max_value).min(dim=dim, keepdim=keepdim)
+    return output
+
+
+def nanvar(tensor, dim=None, keepdim=False):
+    tensor_mean = tensor.nanmean(dim=dim, keepdim=True)
+    output = (tensor - tensor_mean).square().nanmean(dim=dim, keepdim=keepdim)
+    return output
+
+
+def nanstd(tensor, dim=None, keepdim=False):
+    output = nanvar(tensor, dim=dim, keepdim=keepdim)
+    output = output.sqrt()
+    return output
+
+
+def nanprod(tensor, dim=None, keepdim=False):
+    if dim is None:
+        output = tensor.nan_to_num(1).prod()
+    else:
+        output = tensor.nan_to_num(1).prod(dim=dim, keepdim=keepdim)
+    return output
+
+
+def nancumprod(tensor, dim=None, keepdim=False):
+    if dim is None:
+        dim = 0  # Default to first dimension for cumulative operations
+    output = tensor.nan_to_num(1).cumprod(dim=dim)
+    return output
+
+
+def nancumsum(tensor, dim=None, keepdim=False):
+    if dim is None:
+        dim = 0  # Default to first dimension for cumulative operations
+    output = tensor.nan_to_num(0).cumsum(dim=dim)
+    return output
+
+
+def nanargmin(tensor, dim=None, keepdim=False):
+    max_value = _torch.finfo(tensor.dtype).max
+    if dim is None:
+        output = tensor.nan_to_num(max_value).argmin()
+    else:
+        output = tensor.nan_to_num(max_value).argmin(dim=dim, keepdim=keepdim)
+    return output
+
+
+def nanargmax(tensor, dim=None, keepdim=False):
+    min_value = _torch.finfo(tensor.dtype).min
+    if dim is None:
+        output = tensor.nan_to_num(min_value).argmax()
+    else:
+        output = tensor.nan_to_num(min_value).argmax(dim=dim, keepdim=keepdim)
+    return output

scitex/types/_ArrayLike.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-01 09:21:23 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/types/_ArrayLike.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/types/_ArrayLike.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+from typing import List as _List
+from typing import Tuple as _Tuple
+from typing import Union as _Union
+
+import numpy as _np
+import pandas as _pd
+import torch as _torch
+import xarray as _xr
+
+ArrayLike = _Union[
+    _List,
+    _Tuple,
+    _np.ndarray,
+    _pd.Series,
+    _pd.DataFrame,
+    _xr.DataArray,
+    _torch.tensor,
+]
+
+
+def is_array_like(obj) -> bool:
+    """Check if object is array-like.
+    
+    Returns:
+        bool: True if object is array-like, False otherwise.
+    """
+    return isinstance(
+        obj,
+        (_List, _Tuple, _np.ndarray, _pd.Series, _pd.DataFrame, _xr.DataArray),
+    ) or _torch.is_tensor(obj)
+
+
+# EOF

scitex/types/_ColorLike.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-02 17:09:16 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/types/_ColorLike.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/types/_ColorLike.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+from typing import List, Tuple, Union
+
+# Define ColorLike type
+ColorLike = Union[
+    str,
+    Tuple[float, float, float],
+    Tuple[float, float, float, float],
+    List[float],
+]
+
+# EOF

scitex/types/__init__.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+"""Scitex types module."""
+
+from ._ArrayLike import ArrayLike, is_array_like
+from ._ColorLike import ColorLike
+from ._is_listed_X import is_list_of_type, is_listed_X
+
+__all__ = [
+    "ArrayLike",
+    "ColorLike",
+    "is_array_like",
+    "is_list_of_type",
+    "is_listed_X",
+]

scitex/types/_is_listed_X.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-02 17:10:53 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/types/_is_listed_X.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/types/_is_listed_X.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+
+def is_listed_X(obj, types):
+    """
+    Check if obj is a list where all elements are of one of the specified types.
+
+    Args:
+        obj: Object to check
+        types: Type or list of types to check against
+
+    Example:
+        obj = [3, 2, 1, 5]
+        is_listed_X(obj, int)  # Returns True
+        is_listed_X(obj, (int, float))  # Returns True
+        is_listed_X(obj, str)  # Returns False
+
+    Returns:
+        bool: True if obj is a list and all elements are of one of the specified types
+    """
+    import numpy as np
+
+    try:
+        condition_list = isinstance(obj, list)
+
+        if not (isinstance(types, list) or isinstance(types, tuple)):
+            types = [types]
+
+        _conditions_susp = []
+        for typ in types:
+            _conditions_susp.append(
+                (np.array([isinstance(o, typ) for o in obj]) == True).all()
+            )
+
+        condition_susp = np.any(_conditions_susp)
+
+        _is_listed_X = np.all([condition_list, condition_susp])
+        return _is_listed_X
+
+    except:
+        return False
+
+
+# More conventional alias
+def is_list_of_type(obj, types):
+    """
+    Check if obj is a list where all elements are of one of the specified types.
+    
+    This is an alias for is_listed_X with a more conventional name.
+    
+    Args:
+        obj: Object to check
+        types: Type or list of types to check against
+        
+    Returns:
+        bool: True if obj is a list and all elements are of one of the specified types
+    """
+    return is_listed_X(obj, types)
+
+
+# EOF

scitex/utils/__init__.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python3
+"""Scitex utils module."""
+
+from ._compress_hdf5 import compress_hdf5
+from ._email import ansi_escape, send_gmail
+from ._grid import count_grids, yield_grids
+from ._notify import gen_footer, get_git_branch, get_hostname, get_username, notify
+from ._search import search
+
+__all__ = [
+    "ansi_escape",
+    "compress_hdf5",
+    "count_grids",
+    "gen_footer",
+    "get_git_branch",
+    "get_hostname",
+    "get_username",
+    "notify",
+    "search",
+    "send_gmail",
+    "yield_grids",
+]

scitex/utils/_compress_hdf5.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-04-10 08:26:28 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/utils/_compress_hdf5.py
+# ----------------------------------------
+import os
+
+__FILE__ = "/ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/utils/_compress_hdf5.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+import h5py
+import numpy as np
+from tqdm import tqdm
+
+
+def compress_hdf5(input_file, output_file=None, compression_level=4):
+    """
+    Compress an existing HDF5 file by reading all datasets and rewriting them with compression.
+
+    Parameters:
+    -----------
+    input_file : str
+        Path to the input HDF5 file
+    output_file : str, optional
+        Path to the output compressed HDF5 file. If None, will use input_file + '.compressed.h5'
+    compression_level : int, optional
+        Compression level (1-9), higher means more compression but slower processing
+    """
+    if output_file is None:
+        base, ext = os.path.splitext(input_file)
+        output_file = f"{base}.compressed{ext}"
+
+    print(f"Compressing {input_file} to {output_file}")
+
+    with h5py.File(input_file, "r") as src, h5py.File(output_file, "w") as dst:
+        # Copy file attributes
+        for key, value in src.attrs.items():
+            dst.attrs[key] = value
+
+        def copy_dataset(name, obj):
+            if isinstance(obj, h5py.Dataset):
+                # Print progress for large datasets
+                if len(obj.shape) > 0 and obj.shape[0] > 1000000:
+                    print(f"Processing large dataset {name} with shape {obj.shape}")
+
+                # Get original dataset attributes
+                chunks = True  # Let h5py choose chunking
+                if obj.chunks is not None:
+                    chunks = obj.chunks
+
+                # Create the compressed dataset
+                compressed_data = dst.create_dataset(
+                    name,
+                    shape=obj.shape,
+                    dtype=obj.dtype,
+                    compression="gzip",
+                    compression_opts=compression_level,
+                    chunks=chunks,
+                )
+
+                # Copy data and attributes
+                if len(obj.shape) > 0 and obj.shape[0] > 10000000:
+                    # Process large datasets in chunks to avoid memory issues
+                    chunk_size = 5000000  # Adjust based on your available RAM
+                    for i in tqdm(
+                        range(0, obj.shape[0], chunk_size), desc=f"Copying {name}"
+                    ):
+                        end = min(i + chunk_size, obj.shape[0])
+                        if len(obj.shape) == 1:
+                            compressed_data[i:end] = obj[i:end]
+                        else:
+                            compressed_data[i:end, ...] = obj[i:end, ...]
+                else:
+                    # Small enough to copy at once
+                    compressed_data[()] = obj[()]
+
+                # Copy dataset attributes
+                for key, value in obj.attrs.items():
+                    compressed_data.attrs[key] = value
+
+            elif isinstance(obj, h5py.Group):
+                # Create group in destination file
+                group = dst.create_group(name)
+                # Copy group attributes
+                for key, value in obj.attrs.items():
+                    group.attrs[key] = value
+
+        # Process all objects in the file
+        src.visititems(copy_dataset)
+
+    print(
+        f"Compression complete. Original size: {os.path.getsize(input_file)/1e9:.2f} GB, "
+        f"New size: {os.path.getsize(output_file)/1e9:.2f} GB"
+    )
+
+    return output_file
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Compress existing HDF5 files with gzip compression"
+    )
+    parser.add_argument("input_file", help="Path to the input HDF5 file")
+    parser.add_argument(
+        "--output_file", help="Path to the output compressed HDF5 file", default=None
+    )
+    parser.add_argument(
+        "--compression", type=int, help="Compression level (1-9)", default=4
+    )
+
+    args = parser.parse_args()
+    compress_existing_h5(args.input_file, args.output_file, args.compression)
+
+# EOF

scitex/utils/_email.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-03 06:33:08 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/utils/_email.py
+
+import os
+import smtplib
+from email import encoders
+from email.mime.base import MIMEBase as _MIMEBase
+from email.mime.multipart import MIMEMultipart as _MIMEMultipart
+from email.mime.text import MIMEText as _MIMEText
+import mimetypes
+
+from ..reproduce._gen_ID import gen_ID
+
+import re
+
+ansi_escape = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+
+
+def send_gmail(
+    sender_gmail,
+    sender_password,
+    recipient_email,
+    subject,
+    message,
+    sender_name=None,
+    cc=None,
+    ID=None,
+    attachment_paths=None,
+    verbose=True,
+):
+    if ID == "auto":
+        ID = gen_ID()
+
+    if ID:
+        if subject:
+            subject = f"{subject} (ID: {ID})"
+        else:
+            subject = f"ID: {ID}"
+
+    try:
+        server = smtplib.SMTP("smtp.gmail.com", 587)
+        server.starttls()
+        server.login(sender_gmail, sender_password)
+
+        gmail = _MIMEMultipart()
+        gmail["Subject"] = subject
+        gmail["To"] = recipient_email
+        if cc:
+            if isinstance(cc, str):
+                gmail["Cc"] = cc
+            elif isinstance(cc, list):
+                gmail["Cc"] = ", ".join(cc)
+        if sender_name:
+            gmail["From"] = f"{sender_name} <{sender_gmail}>"
+        else:
+            gmail["From"] = sender_gmail
+        gmail_body = _MIMEText(message, "plain")
+        gmail.attach(gmail_body)
+
+        # Attachment files
+        if attachment_paths:
+            for path in attachment_paths:
+                _, ext = os.path.splitext(path)
+                if ext.lower() == ".log":
+                    with open(path, "r", encoding="utf-8") as file:
+                        content = file.read()
+                        cleaned_content = ansi_escape.sub("", content)
+                        part = _MIMEText(cleaned_content, "plain")
+
+                        # part = _MIMEText(file.read(), 'plain')
+                else:
+                    mime_type, _ = mimetypes.guess_type(path)
+                    if mime_type is None:
+                        mime_type = "text/plain"
+                    main_type, sub_type = mime_type.split("/", 1)
+                    with open(path, "rb") as file:
+                        part = _MIMEBase(main_type, sub_type)
+                        part.set_payload(file.read())
+                        encoders.encode_base64(part)
+
+                part.add_header(
+                    "Content-Disposition",
+                    f"attachment; filename={os.path.basename(path)}",
+                )
+                gmail.attach(part)
+
+        recipients = [recipient_email]
+        if cc:
+            if isinstance(cc, str):
+                recipients.append(cc)
+            elif isinstance(cc, list):
+                recipients.extend(cc)
+        server.send_message(gmail, to_addrs=recipients)
+
+        server.quit()
+
+        if verbose:
+            cc_info = f" (CC: {cc})" if cc else ""
+            message = f"Email was sent:\n"
+            message += f"    {sender_gmail} -> {recipient_email}{cc_info}\n"
+            message += f"    (ID: {ID})\n"
+            if attachment_paths:
+                message += f"    Attached:\n"
+                for ap in attachment_paths:
+                    message += f"        {ap}\n"
+            print(message)
+
+            # message = f"\nEmail was sent:\n\t{sender_gmail} -> {recipient_email}{cc_info}\n\t(ID: {ID})"
+            # if attachment_paths:
+            #     attachment_paths_str = '\n\t\t'.join(attachment_paths)
+            #     message += f"\n\tAttached:\n\t{attachment_paths_str}"
+            # print(message)
+
+    except Exception as e:
+        print(f"Email was not sent: {e}")
+
+
+# EOF