scitex 2.7.3__py3-none-any.whl → 2.10.0__py3-none-any.whl

scitex/stats/descriptive/_real.py

@@ -1,190 +1,176 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Timestamp: "2025-09-20 14:56:35 (ywatanabe)"
-# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/stats/desc/_real_dev.py
-# ----------------------------------------
+# Timestamp: "2025-12-27 (refactored)"
+# File: scitex/stats/descriptive/_real.py
+"""
+Descriptive statistics for real-valued data.
+
+Uses torch when available (preserves tensor type), falls back to numpy.
+"""
+
 from __future__ import annotations
+
 import os
 
+import numpy as np
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
-# ----------------------------------------
 
-"""
-Functionalities:
-- Computes descriptive statistics on PyTorch tensors
-- Provides mean, standard deviation, variance calculations
-- Calculates z-scores, skewness, kurtosis
-- Computes quantiles (25th, 50th, 75th percentiles)
-- Demonstrates statistical computations with synthetic data
-
-Dependencies:
-- packages:
-  - torch
-  - numpy
-  - scitex
-
-IO:
-- input-files:
-  - PyTorch tensor or numpy array
-- output-files:
-  - Descriptive statistics results
-"""
+# Optional torch support
+try:
+    import torch
 
-"""Imports"""
-import argparse
+    HAS_TORCH = True
+except ImportError:
+    torch = None
+    HAS_TORCH = False
 
-import numpy as np
-import scitex as stx
-import torch
-from scitex import logging
 
-from scitex.decorators import torch_fn
+def _is_torch_tensor(x):
+    """Check if x is a torch tensor."""
+    return HAS_TORCH and isinstance(x, torch.Tensor)
+
 
-logger = logging.getLogger(__name__)
+def _normalize_axis(axis, dim):
+    """Normalize axis/dim parameter."""
+    return dim if dim is not None else axis
 
-"""Functions & Classes"""
+
+# =============================================================================
+# Core Functions - Use torch when input is tensor, numpy otherwise
+# =============================================================================
 
 
-@torch_fn
 def mean(x, axis=-1, dim=None, keepdims=False):
-    return x.mean(dim, keepdims=keepdims)
+    """Compute mean along specified axis.
+
+    Parameters
+    ----------
+    x : array-like
+        Input data (numpy array or torch tensor)
+    axis : int, default=-1
+        Axis along which to compute (deprecated, use dim)
+    dim : int or tuple, optional
+        Dimension(s) along which to compute
+    keepdims : bool, default=False
+        Keep reduced dimensions
+
+    Returns
+    -------
+    ndarray or Tensor
+        Mean values (same type as input)
+    """
+    dim = _normalize_axis(axis, dim)
+    if _is_torch_tensor(x):
+        return x.mean(dim=dim, keepdim=keepdims)
+    return np.mean(np.asarray(x), axis=dim, keepdims=keepdims)
 
 
-@torch_fn
 def std(x, axis=-1, dim=None, keepdims=False):
-    return x.std(dim, keepdims=keepdims)
+    """Compute standard deviation along specified axis."""
+    dim = _normalize_axis(axis, dim)
+    if _is_torch_tensor(x):
+        return x.std(dim=dim, keepdim=keepdims)
+    return np.std(np.asarray(x), axis=dim, keepdims=keepdims)
 
 
-@torch_fn
 def var(x, axis=-1, dim=None, keepdims=False):
-    return x.var(dim, keepdims=keepdims)
+    """Compute variance along specified axis."""
+    dim = _normalize_axis(axis, dim)
+    if _is_torch_tensor(x):
+        return x.var(dim=dim, keepdim=keepdims)
+    return np.var(np.asarray(x), axis=dim, keepdims=keepdims)
 
 
-@torch_fn
 def zscore(x, axis=-1, dim=None, keepdims=True):
-    _mean = mean(x, dim=dim, keepdims=True)
-    _std = std(x, dim=dim, keepdims=True)
-    zscores = (x - _mean) / _std
-    return zscores if keepdims else zscores.squeeze(dim)
+    """Compute z-scores along specified axis."""
+    dim = _normalize_axis(axis, dim)
+    if _is_torch_tensor(x):
+        _mean = x.mean(dim=dim, keepdim=True)
+        _std = x.std(dim=dim, keepdim=True)
+        zscores = (x - _mean) / _std
+        return zscores if keepdims else zscores.squeeze(dim)
+    else:
+        x = np.asarray(x)
+        _mean = np.mean(x, axis=dim, keepdims=True)
+        _std = np.std(x, axis=dim, keepdims=True)
+        zscores = (x - _mean) / _std
+        if not keepdims and dim is not None:
+            zscores = np.squeeze(zscores, axis=dim)
+        return zscores
 
 
-@torch_fn
 def skewness(x, axis=-1, dim=None, keepdims=False):
-    zscores = zscore(x, axis=axis, keepdims=True)
-    return torch.mean(torch.pow(zscores, 3.0), dim=dim, keepdims=keepdims)
+    """Compute skewness along specified axis."""
+    dim = _normalize_axis(axis, dim)
+    zscores = zscore(x, dim=dim, keepdims=True)
+    if _is_torch_tensor(x):
+        return torch.mean(torch.pow(zscores, 3.0), dim=dim, keepdim=keepdims)
+    return np.mean(np.power(zscores, 3.0), axis=dim, keepdims=keepdims)
 
 
-@torch_fn
 def kurtosis(x, axis=-1, dim=None, keepdims=False):
-    zscores = zscore(x, axis=axis, keepdims=True)
-    return torch.mean(torch.pow(zscores, 4.0), dim=dim, keepdims=keepdims) - 3.0
+    """Compute excess kurtosis along specified axis."""
+    dim = _normalize_axis(axis, dim)
+    zscores = zscore(x, dim=dim, keepdims=True)
+    if _is_torch_tensor(x):
+        return torch.mean(torch.pow(zscores, 4.0), dim=dim, keepdim=keepdims) - 3.0
+    return np.mean(np.power(zscores, 4.0), axis=dim, keepdims=keepdims) - 3.0
 
 
-@torch_fn
 def quantile(x, q, axis=-1, dim=None, keepdims=False):
-    dim = axis if dim is None else dim
-    if isinstance(dim, (tuple, list)):
-        for d in sorted(dim, reverse=True):
-            x = torch.quantile(x, q / 100, dim=d, keepdims=keepdims)
+    """Compute quantile along specified axis.
+
+    Parameters
+    ----------
+    x : array-like
+        Input data
+    q : float
+        Quantile to compute (0-100)
+    axis : int, default=-1
+        Axis along which to compute
+    dim : int or tuple, optional
+        Dimension(s) along which to compute
+    keepdims : bool, default=False
+        Keep reduced dimensions
+
+    Returns
+    -------
+    ndarray or Tensor
+        Quantile values
+    """
+    dim = _normalize_axis(axis, dim)
+
+    if _is_torch_tensor(x):
+        if isinstance(dim, (tuple, list)):
+            result = x
+            for d in sorted(dim, reverse=True):
+                result = torch.quantile(result, q / 100, dim=d, keepdim=keepdims)
+            return result
+        return torch.quantile(x, q / 100, dim=dim, keepdim=keepdims)
     else:
-        x = torch.quantile(x, q / 100, dim=dim, keepdims=keepdims)
-    return x
+        x = np.asarray(x)
+        if isinstance(dim, (tuple, list)):
+            result = x
+            for d in sorted(dim, reverse=True):
+                result = np.quantile(result, q / 100, axis=d, keepdims=keepdims)
+            return result
+        return np.quantile(x, q / 100, axis=dim, keepdims=keepdims)
 
 
-@torch_fn
 def q25(x, axis=-1, dim=None, keepdims=False):
+    """Compute 25th percentile."""
     return quantile(x, 25, axis=axis, dim=dim, keepdims=keepdims)
 
 
-@torch_fn
 def q50(x, axis=-1, dim=None, keepdims=False):
+    """Compute 50th percentile (median)."""
     return quantile(x, 50, axis=axis, dim=dim, keepdims=keepdims)
 
 
-@torch_fn
 def q75(x, axis=-1, dim=None, keepdims=False):
+    """Compute 75th percentile."""
     return quantile(x, 75, axis=axis, dim=dim, keepdims=keepdims)
 
 
-def main(args) -> int:
-    """Demonstrate descriptive statistics functions with synthetic data."""
-    x = np.random.rand(4, 3, 2)
-
-    # Compute statistics
-    x_mean = mean(x)
-    x_std = std(x)
-    x_var = var(x)
-    x_skew = skewness(x)
-    x_kurt = kurtosis(x)
-    x_q25 = q25(x)
-    x_q50 = q50(x)
-    x_q75 = q75(x)
-
-    # Store results
-    results = {
-        "input": x,
-        "mean": x_mean,
-        "std": x_std,
-        "variance": x_var,
-        "skewness": x_skew,
-        "kurtosis": x_kurt,
-        "q25": x_q25,
-        "q50": x_q50,
-        "q75": x_q75,
-    }
-
-    for k, v in results.items():
-        if isinstance(v, (np.ndarray, torch.Tensor)):
-            print(f"\n{k}, Type: {type(v)}, Shape: {v.shape}, Values: {v}")
-        elif isinstance(v, list):
-            print(f"\n{k}, Type: {type(v)}, Length: {len(v)}, Values: {v}")
-        else:
-            print(f"\n{k}, Type: {type(v)}, Values: {v}")
-
-    return 0
-
-
-def parse_args() -> argparse.Namespace:
-    """Parse command line arguments."""
-    parser = argparse.ArgumentParser(
-        description="Demonstrate descriptive statistics functions"
-    )
-    args = parser.parse_args()
-    return args
-
-
-def run_main() -> None:
-    """Initialize scitex framework, run main function, and cleanup."""
-    global CONFIG, CC, sys, plt, rng
-    import sys
-
-    import matplotlib.pyplot as plt
-    import scitex as stx
-
-    args = parse_args()
-    CONFIG, sys.stdout, sys.stderr, plt, CC, rng_manager = stx.session.start(
-        sys,
-        plt,
-        args=args,
-        file=__FILE__,
-        sdir_suffix=None,
-        verbose=False,
-        agg=True,
-    )
-
-    exit_status = main(args)
-
-    stx.session.close(
-        CONFIG,
-        verbose=False,
-        notify=False,
-        message="",
-        exit_status=exit_status,
-    )
-
-
-if __name__ == "__main__":
-    run_main()
-
 # EOF

scitex/str/_format_plot_text.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Time-stamp: "2025-06-04 11:08:00 (ywatanabe)"
 # File: ./src/scitex/str/_format_plot_text.py
 
@@ -16,10 +15,10 @@ Prerequisites:
 """
 
 import re
-from typing import Union, Tuple, Optional
+from typing import Optional, Tuple
 
 try:
-    from ._latex_fallback import safe_latex_render, latex_fallback_decorator
+    from ._latex_fallback import latex_fallback_decorator, safe_latex_render
 
     FALLBACK_AVAILABLE = True
 except ImportError:
@@ -102,10 +101,11 @@ def format_plot_text(
 
     if latex_math:
         # Extract and preserve LaTeX math
+        # Use ||| delimiters to avoid being processed by _replace_underscores
         latex_pattern = r"\$[^$]+\$"
         latex_matches = re.findall(latex_pattern, text)
         for i, match in enumerate(latex_matches):
-            placeholder = f"__LATEX_{i}__"
+            placeholder = f"|||LATEX{i}|||"
             latex_sections.append(match)
             text_working = text_working.replace(match, placeholder, 1)
 
@@ -126,7 +126,7 @@ def format_plot_text(
 
     # Restore LaTeX sections with fallback handling
     for i, latex_section in enumerate(latex_sections):
-        placeholder = f"__LATEX_{i}__"
+        placeholder = f"|||LATEX{i}|||"
         if enable_fallback and FALLBACK_AVAILABLE:
             # Apply fallback to LaTeX sections
             safe_latex = safe_latex_render(latex_section, preserve_math=True)

scitex/str/_latex.py

@@ -1,29 +1,25 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Time-stamp: "2025-06-05 12:00:00 (ywatanabe)"
 # File: ./src/scitex/str/_latex.py
 
 """
-LaTeX formatting functions with fallback mechanisms.
+LaTeX formatting functions for string manipulation.
 
 Functionality:
-    - LaTeX text formatting with automatic fallback
-    - Safe handling of LaTeX rendering failures
+    - Convert strings/numbers to LaTeX math mode format
+    - Add LaTeX hat notation
 Input:
     Strings or numbers to format
 Output:
-    LaTeX-formatted strings with fallback support
+    LaTeX-formatted strings (wrapped in $...$)
 Prerequisites:
-    matplotlib, _latex_fallback module
+    None (pure string formatting)
 """
 
-from ._latex_fallback import safe_latex_render, latex_fallback_decorator
 
-
-@latex_fallback_decorator(fallback_strategy="auto", preserve_math=True)
 def to_latex_style(str_or_num):
     """
-    Convert string or number to LaTeX math mode format with fallback.
+    Convert string or number to LaTeX math mode format.
 
     Parameters
     ----------
@@ -33,38 +29,34 @@ def to_latex_style(str_or_num):
     Returns
     -------
     str
-        LaTeX-formatted string with automatic fallback
+        LaTeX-formatted string wrapped in $...$
 
     Examples
     --------
     >>> to_latex_style('aaa')
     '$aaa$'
 
-    >>> to_latex_style('alpha')  # Falls back to unicode if LaTeX fails
-    'α'
+    >>> to_latex_style('x^2')
+    '$x^2$'
 
-    Notes
-    -----
-    If LaTeX rendering fails (e.g., due to missing fonts or Node.js conflicts),
-    this function automatically falls back to mathtext or unicode alternatives.
+    >>> to_latex_style(123)
+    '$123$'
     """
-    if not str_or_num and str_or_num != 0:  # Handle empty string case
+    if not str_or_num and str_or_num != 0:
         return ""
 
     string = str(str_or_num)
 
     # Avoid double-wrapping
     if len(string) >= 2 and string[0] == "$" and string[-1] == "$":
-        return safe_latex_render(string)
+        return string
     else:
-        latex_string = "${}$".format(string)
-        return safe_latex_render(latex_string)
+        return f"${string}$"
 
 
-@latex_fallback_decorator(fallback_strategy="auto", preserve_math=True)
 def add_hat_in_latex_style(str_or_num):
     """
-    Add LaTeX hat notation to string with fallback.
+    Add LaTeX hat notation to string.
 
     Parameters
     ----------
@@ -74,82 +66,32 @@ def add_hat_in_latex_style(str_or_num):
     Returns
     -------
     str
-        LaTeX-formatted string with hat notation and automatic fallback
+        LaTeX-formatted string with hat notation
 
     Examples
     --------
     >>> add_hat_in_latex_style('aaa')
     '$\\hat{aaa}$'
 
-    >>> add_hat_in_latex_style('x')  # Falls back to unicode if LaTeX fails
-    'x̂'
-
-    Notes
-    -----
-    If LaTeX rendering fails, this function falls back to unicode hat
-    notation or plain text alternatives.
-    """
-    if not str_or_num and str_or_num != 0:  # Handle empty string case
-        return ""
-
-    hat_latex = r"\hat{%s}" % str_or_num
-    latex_string = to_latex_style(hat_latex)
-    return safe_latex_render(latex_string)
-
+    >>> add_hat_in_latex_style('x')
+    '$\\hat{x}$'
 
-def safe_to_latex_style(str_or_num, fallback_strategy="auto"):
-    """
-    Safe version of to_latex_style with explicit fallback control.
-
-    Parameters
-    ----------
-    str_or_num : str or numeric
-        Input to format in LaTeX style
-    fallback_strategy : str, optional
-        Explicit fallback strategy: "auto", "mathtext", "unicode", "plain"
-
-    Returns
-    -------
-    str
-        Formatted string with specified fallback behavior
+    >>> add_hat_in_latex_style(1)
+    '$\\hat{1}$'
     """
     if not str_or_num and str_or_num != 0:
         return ""
 
-    string = str(str_or_num)
-    if len(string) >= 2 and string[0] == "$" and string[-1] == "$":
-        return safe_latex_render(string, fallback_strategy)
-    else:
-        latex_string = "${}$".format(string)
-        return safe_latex_render(latex_string, fallback_strategy)
-
-
-def safe_add_hat_in_latex_style(str_or_num, fallback_strategy="auto"):
-    """
-    Safe version of add_hat_in_latex_style with explicit fallback control.
-
-    Parameters
-    ----------
-    str_or_num : str or numeric
-        Input to format with hat notation
-    fallback_strategy : str, optional
-        Explicit fallback strategy: "auto", "mathtext", "unicode", "plain"
-
-    Returns
-    -------
-    str
-        Formatted string with hat notation and specified fallback behavior
-    """
-    if not str_or_num and str_or_num != 0:
-        return ""
-
-    hat_latex = r"\hat{%s}" % str_or_num
-    latex_string = safe_to_latex_style(hat_latex, fallback_strategy)
-    return latex_string
+    hat_latex = rf"\hat{{{str_or_num}}}"
+    return f"${hat_latex}$"
 
 
 # Backward compatibility aliases
 latex_style = to_latex_style
 hat_latex_style = add_hat_in_latex_style
 
+# Safe versions that are identical (no fallback needed for pure formatting)
+safe_to_latex_style = to_latex_style
+safe_add_hat_in_latex_style = add_hat_in_latex_style
+
 # EOF

scitex/str/_latex_fallback.py

@@ -1,9 +1,9 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Timestamp: "2025-08-21 21:37:23 (ywatanabe)"
 # File: /home/ywatanabe/proj/scitex_repo/src/scitex/str/_latex_fallback.py
 # ----------------------------------------
 from __future__ import annotations
+
 import os
 
 __FILE__ = __file__
@@ -170,59 +170,65 @@ def latex_to_mathtext(latex_str: str) -> str:
     if text.startswith("$") and text.endswith("$"):
         text = text[1:-1]
 
-    # Common LaTeX to mathtext conversions
-    conversions = {
+    # Simple string replacements (double backslash to single)
+    simple_conversions = {
         # Greek letters
-        r"\\alpha": r"\alpha",
-        r"\\beta": r"\beta",
-        r"\\gamma": r"\gamma",
-        r"\\delta": r"\delta",
-        r"\\epsilon": r"\epsilon",
-        r"\\theta": r"\theta",
-        r"\\lambda": r"\lambda",
-        r"\\mu": r"\mu",
-        r"\\pi": r"\pi",
-        r"\\sigma": r"\sigma",
-        r"\\tau": r"\tau",
-        r"\\phi": r"\phi",
-        r"\\omega": r"\omega",
+        r"\\alpha": "\\alpha",
+        r"\\beta": "\\beta",
+        r"\\gamma": "\\gamma",
+        r"\\delta": "\\delta",
+        r"\\epsilon": "\\epsilon",
+        r"\\theta": "\\theta",
+        r"\\lambda": "\\lambda",
+        r"\\mu": "\\mu",
+        r"\\pi": "\\pi",
+        r"\\sigma": "\\sigma",
+        r"\\tau": "\\tau",
+        r"\\phi": "\\phi",
+        r"\\omega": "\\omega",
         # Mathematical symbols
-        r"\\sum": r"\sum",
-        r"\\int": r"\int",
-        r"\\partial": r"\partial",
-        r"\\infty": r"\infty",
-        r"\\pm": r"\pm",
-        r"\\times": r"\times",
-        r"\\cdot": r"\cdot",
-        r"\\approx": r"\approx",
-        r"\\neq": r"\neq",
-        r"\\leq": r"\leq",
-        r"\\geq": r"\geq",
+        r"\\sum": "\\sum",
+        r"\\int": "\\int",
+        r"\\partial": "\\partial",
+        r"\\infty": "\\infty",
+        r"\\pm": "\\pm",
+        r"\\times": "\\times",
+        r"\\cdot": "\\cdot",
+        r"\\approx": "\\approx",
+        r"\\neq": "\\neq",
+        r"\\leq": "\\leq",
+        r"\\geq": "\\geq",
         # Functions
-        r"\\sin": r"\sin",
-        r"\\cos": r"\cos",
-        r"\\tan": r"\tan",
-        r"\\log": r"\log",
-        r"\\ln": r"\ln",
-        r"\\exp": r"\exp",
+        r"\\sin": "\\sin",
+        r"\\cos": "\\cos",
+        r"\\tan": "\\tan",
+        r"\\log": "\\log",
+        r"\\ln": "\\ln",
+        r"\\exp": "\\exp",
+    }
+
+    # Apply simple string replacements
+    for pattern, replacement in simple_conversions.items():
+        text = text.replace(pattern, replacement)
+
+    # Regex patterns with capture groups
+    regex_conversions = [
         # Formatting (limited mathtext support)
-        r"\\textbf\{([^}]+)\}": r"\mathbf{\1}",
-        r"\\mathbf\{([^}]+)\}": r"\mathbf{\1}",
-        r"\\textit\{([^}]+)\}": r"\mathit{\1}",
-        r"\\mathit\{([^}]+)\}": r"\mathit{\1}",
+        (r"\\textbf\{([^}]+)\}", r"\\mathbf{\1}"),
+        (r"\\mathbf\{([^}]+)\}", r"\\mathbf{\1}"),
+        (r"\\textit\{([^}]+)\}", r"\\mathit{\1}"),
+        (r"\\mathit\{([^}]+)\}", r"\\mathit{\1}"),
         # Hats and accents
-        r"\\hat\{([^}]+)\}": r"\hat{\1}",
-        r"\\overrightarrow\{([^}]+)\}": r"\vec{\1}",
-        r"\\vec\{([^}]+)\}": r"\vec{\1}",
+        (r"\\hat\{([^}]+)\}", r"\\hat{\1}"),
+        (r"\\overrightarrow\{([^}]+)\}", r"\\vec{\1}"),
+        (r"\\vec\{([^}]+)\}", r"\\vec{\1}"),
         # Fractions (simple ones)
-        r"\\frac\{([^}]+)\}\{([^}]+)\}": r"\frac{\1}{\2}",
-        # Subscripts and superscripts (should work as-is)
-        # Powers and indices are handled naturally by mathtext
-    }
+        (r"\\frac\{([^}]+)\}\{([^}]+)\}", r"\\frac{\1}{\2}"),
+    ]
 
-    # Apply conversions
-    for latex_pattern, mathtext_replacement in conversions.items():
-        text = re.sub(latex_pattern, mathtext_replacement, text)
+    # Apply regex conversions
+    for pattern, replacement in regex_conversions:
+        text = re.sub(pattern, replacement, text)
 
     # Wrap in mathtext markers
     return f"${text}$"