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

scitex/plt/_subplots/_mm_layout.py

@@ -0,0 +1,282 @@
+#!/usr/bin/env python3
+"""Millimeter-based layout control for matplotlib figures."""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from ._AxesWrapper import AxesWrapper
+from ._AxisWrapper import AxisWrapper
+from ._FigWrapper import FigWrapper
+
+
+def create_with_mm_control(
+    *args,
+    track=True,
+    sharex=False,
+    sharey=False,
+    axes_width_mm=None,
+    axes_height_mm=None,
+    margin_left_mm=None,
+    margin_right_mm=None,
+    margin_bottom_mm=None,
+    margin_top_mm=None,
+    space_w_mm=None,
+    space_h_mm=None,
+    axes_thickness_mm=None,
+    tick_length_mm=None,
+    tick_thickness_mm=None,
+    trace_thickness_mm=None,
+    marker_size_mm=None,
+    axis_font_size_pt=None,
+    tick_font_size_pt=None,
+    title_font_size_pt=None,
+    legend_font_size_pt=None,
+    suptitle_font_size_pt=None,
+    label_pad_pt=None,
+    tick_pad_pt=None,
+    title_pad_pt=None,
+    font_family=None,
+    n_ticks=None,
+    mode=None,
+    dpi=None,
+    styles=None,
+    transparent=None,
+    theme=None,
+    **kwargs,
+):
+    """Create figure with mm-based control over axes dimensions.
+
+    Returns
+    -------
+    tuple
+        (FigWrapper, AxisWrapper or AxesWrapper)
+    """
+    from scitex.plt.utils import apply_style_mm, mm_to_inch
+
+    # Parse nrows, ncols from args or kwargs
+    nrows, ncols = 1, 1
+    if len(args) >= 1:
+        nrows = args[0]
+    elif "nrows" in kwargs:
+        nrows = kwargs.pop("nrows")
+    if len(args) >= 2:
+        ncols = args[1]
+    elif "ncols" in kwargs:
+        ncols = kwargs.pop("ncols")
+
+    n_axes = nrows * ncols
+
+    # Apply mode-specific defaults
+    if mode == "display":
+        scale_factor = 3.0
+        dpi = dpi or 100
+    else:
+        scale_factor = 1.0
+        dpi = dpi or 300
+
+    # Set defaults with scaling
+    if axes_width_mm is None:
+        axes_width_mm = 30.0 * scale_factor
+    elif mode == "display":
+        axes_width_mm = axes_width_mm * scale_factor
+
+    if axes_height_mm is None:
+        axes_height_mm = 21.0 * scale_factor
+    elif mode == "display":
+        axes_height_mm = axes_height_mm * scale_factor
+
+    margin_left_mm = (
+        margin_left_mm if margin_left_mm is not None else (5.0 * scale_factor)
+    )
+    margin_right_mm = (
+        margin_right_mm if margin_right_mm is not None else (2.0 * scale_factor)
+    )
+    margin_bottom_mm = (
+        margin_bottom_mm if margin_bottom_mm is not None else (5.0 * scale_factor)
+    )
+    margin_top_mm = margin_top_mm if margin_top_mm is not None else (2.0 * scale_factor)
+    space_w_mm = space_w_mm if space_w_mm is not None else (3.0 * scale_factor)
+    space_h_mm = space_h_mm if space_h_mm is not None else (3.0 * scale_factor)
+
+    # Handle list vs scalar for axes dimensions
+    if isinstance(axes_width_mm, (list, tuple)):
+        ax_widths_mm = list(axes_width_mm)
+        if len(ax_widths_mm) != n_axes:
+            raise ValueError(
+                f"axes_width_mm list length ({len(ax_widths_mm)}) "
+                f"must match nrows*ncols ({n_axes})"
+            )
+    else:
+        ax_widths_mm = [axes_width_mm] * n_axes
+
+    if isinstance(axes_height_mm, (list, tuple)):
+        ax_heights_mm = list(axes_height_mm)
+        if len(ax_heights_mm) != n_axes:
+            raise ValueError(
+                f"axes_height_mm list length ({len(ax_heights_mm)}) "
+                f"must match nrows*ncols ({n_axes})"
+            )
+    else:
+        ax_heights_mm = [axes_height_mm] * n_axes
+
+    # Calculate figure size from axes grid
+    ax_widths_2d = np.array(ax_widths_mm).reshape(nrows, ncols)
+    ax_heights_2d = np.array(ax_heights_mm).reshape(nrows, ncols)
+
+    max_widths_per_col = ax_widths_2d.max(axis=0)
+    max_heights_per_row = ax_heights_2d.max(axis=1)
+
+    total_width_mm = (
+        margin_left_mm
+        + max_widths_per_col.sum()
+        + (ncols - 1) * space_w_mm
+        + margin_right_mm
+    )
+    total_height_mm = (
+        margin_bottom_mm
+        + max_heights_per_row.sum()
+        + (nrows - 1) * space_h_mm
+        + margin_top_mm
+    )
+
+    # Create figure
+    figsize_inch = (mm_to_inch(total_width_mm), mm_to_inch(total_height_mm))
+    if transparent:
+        fig_mpl = plt.figure(figsize=figsize_inch, dpi=dpi, facecolor="none")
+    else:
+        fig_mpl = plt.figure(figsize=figsize_inch, dpi=dpi)
+
+    # Store theme on figure
+    if theme is not None:
+        fig_mpl._scitex_theme = theme
+
+    # Create axes array and position each one manually
+    axes_mpl_list = []
+    ax_idx = 0
+
+    for row in range(nrows):
+        for col in range(ncols):
+            # Calculate position
+            left_mm = margin_left_mm + max_widths_per_col[:col].sum() + col * space_w_mm
+            rows_below = nrows - row - 1
+            bottom_mm = (
+                margin_bottom_mm
+                + max_heights_per_row[row + 1 :].sum()
+                + rows_below * space_h_mm
+            )
+
+            # Convert to figure coordinates [0-1]
+            left = left_mm / total_width_mm
+            bottom = bottom_mm / total_height_mm
+            width = ax_widths_mm[ax_idx] / total_width_mm
+            height = ax_heights_mm[ax_idx] / total_height_mm
+
+            # Create axes
+            ax_mpl = fig_mpl.add_axes([left, bottom, width, height])
+            if transparent:
+                ax_mpl.patch.set_alpha(0.0)
+            axes_mpl_list.append(ax_mpl)
+
+            # Tag with metadata
+            ax_mpl._scitex_metadata = {
+                "created_with": "scitex.plt.subplots",
+                "mode": mode or "publication",
+                "axes_size_mm": (ax_widths_mm[ax_idx], ax_heights_mm[ax_idx]),
+                "position_in_grid": (row, col),
+            }
+            ax_idx += 1
+
+    # Apply styling to each axes
+    suptitle_font_size_pt_value = None
+    for i, ax_mpl in enumerate(axes_mpl_list):
+        # Determine which style dict to use
+        if styles is not None:
+            if isinstance(styles, list):
+                if len(styles) != n_axes:
+                    raise ValueError(
+                        f"styles list length ({len(styles)}) "
+                        f"must match nrows*ncols ({n_axes})"
+                    )
+                style_dict = styles[i]
+            else:
+                style_dict = styles
+        else:
+            # Build style dict from individual parameters
+            style_dict = {}
+            if axes_thickness_mm is not None:
+                style_dict["axis_thickness_mm"] = axes_thickness_mm
+            if tick_length_mm is not None:
+                style_dict["tick_length_mm"] = tick_length_mm
+            if tick_thickness_mm is not None:
+                style_dict["tick_thickness_mm"] = tick_thickness_mm
+            if trace_thickness_mm is not None:
+                style_dict["trace_thickness_mm"] = trace_thickness_mm
+            if marker_size_mm is not None:
+                style_dict["marker_size_mm"] = marker_size_mm
+            if axis_font_size_pt is not None:
+                style_dict["axis_font_size_pt"] = axis_font_size_pt
+            if tick_font_size_pt is not None:
+                style_dict["tick_font_size_pt"] = tick_font_size_pt
+            if title_font_size_pt is not None:
+                style_dict["title_font_size_pt"] = title_font_size_pt
+            if legend_font_size_pt is not None:
+                style_dict["legend_font_size_pt"] = legend_font_size_pt
+            if suptitle_font_size_pt is not None:
+                style_dict["suptitle_font_size_pt"] = suptitle_font_size_pt
+            if label_pad_pt is not None:
+                style_dict["label_pad_pt"] = label_pad_pt
+            if tick_pad_pt is not None:
+                style_dict["tick_pad_pt"] = tick_pad_pt
+            if title_pad_pt is not None:
+                style_dict["title_pad_pt"] = title_pad_pt
+            if font_family is not None:
+                style_dict["font_family"] = font_family
+            if n_ticks is not None:
+                style_dict["n_ticks"] = n_ticks
+
+        # Always add theme to style_dict
+        if theme is not None:
+            style_dict["theme"] = theme
+
+        # Extract suptitle font size if available
+        if "suptitle_font_size_pt" in style_dict:
+            suptitle_font_size_pt_value = style_dict["suptitle_font_size_pt"]
+
+        # Apply style if not empty
+        if style_dict:
+            apply_style_mm(ax_mpl, style_dict)
+            ax_mpl._scitex_metadata["style_mm"] = style_dict
+
+    # Store suptitle font size in figure metadata
+    if suptitle_font_size_pt_value is not None:
+        fig_mpl._scitex_suptitle_font_size_pt = suptitle_font_size_pt_value
+
+    # Wrap the figure
+    fig_scitex = FigWrapper(fig_mpl)
+
+    # Reshape axes list
+    axes_array_mpl = np.array(axes_mpl_list).reshape(nrows, ncols)
+
+    # Handle single axis case
+    if n_axes == 1:
+        ax_mpl_scalar = axes_array_mpl.item()
+        axis_scitex = AxisWrapper(fig_scitex, ax_mpl_scalar, track)
+        fig_scitex.axes = [axis_scitex]
+        ax_mpl_scalar._scitex_wrapper = axis_scitex
+        return fig_scitex, axis_scitex
+
+    # Handle multiple axes case
+    axes_flat_scitex_list = []
+    for ax_mpl in axes_mpl_list:
+        ax_scitex = AxisWrapper(fig_scitex, ax_mpl, track)
+        ax_mpl._scitex_wrapper = ax_scitex
+        axes_flat_scitex_list.append(ax_scitex)
+
+    axes_array_scitex = np.array(axes_flat_scitex_list).reshape(nrows, ncols)
+    axes_scitex = AxesWrapper(fig_scitex, axes_array_scitex)
+    fig_scitex.axes = axes_scitex
+
+    return fig_scitex, axes_scitex
+
+
+# EOF

scitex/plt/gallery/__init__.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Timestamp: "2025-12-08 23:30:00 (ywatanabe)"
+# Timestamp: "2025-12-18 (ywatanabe)"
 # File: /home/ywatanabe/proj/scitex-code/src/scitex/plt/gallery/__init__.py
 
 """
@@ -19,11 +19,108 @@ Usage:
 
     # List available plots
     stx.plt.gallery.list()
+
+    # Get plot spec and data for bundle creation
+    spec = stx.plt.gallery.get_plot_spec("line", "plot")
+    data = stx.plt.gallery.get_plot_data("line", "plot")
 """
 
 from ._generate import generate
 from ._registry import CATEGORIES, list_plots
+from ._plots import PLOT_FUNCTIONS
+
+
+def get_plot_spec(category: str, plot_name: str) -> dict:
+    """Get spec dictionary for a gallery plot.
+
+    Parameters
+    ----------
+    category : str
+        Plot category (e.g., "line", "scatter", "categorical")
+    plot_name : str
+        Plot name within the category (e.g., "plot", "scatter", "bar")
+
+    Returns
+    -------
+    dict
+        Spec dictionary for the plot type.
+    """
+    if category not in CATEGORIES:
+        raise ValueError(f"Unknown category: {category}. Available: {list(CATEGORIES.keys())}")
+
+    if plot_name not in CATEGORIES[category]["plots"]:
+        raise ValueError(f"Unknown plot: {plot_name} in category {category}")
+
+    # Build a minimal spec for this plot type
+    return {
+        "schema": {"name": "scitex.plt.plot", "version": "1.0.0"},
+        "plot_type": plot_name,
+        "category": category,
+        "axes": {"xlabel": "", "ylabel": ""},
+    }
+
+
+def get_plot_data(category: str, plot_name: str):
+    """Get sample data for a gallery plot as DataFrame.
+
+    Parameters
+    ----------
+    category : str
+        Plot category (e.g., "line", "scatter", "categorical")
+    plot_name : str
+        Plot name within the category (e.g., "plot", "scatter", "bar")
+
+    Returns
+    -------
+    pandas.DataFrame or None
+        Sample data for the plot, or None if plot doesn't use CSV data.
+    """
+    import io
+    import tempfile
+    from pathlib import Path
+
+    if category not in CATEGORIES:
+        raise ValueError(f"Unknown category: {category}. Available: {list(CATEGORIES.keys())}")
+
+    if plot_name not in CATEGORIES[category]["plots"]:
+        raise ValueError(f"Unknown plot: {plot_name} in category {category}")
+
+    if plot_name not in PLOT_FUNCTIONS:
+        return None
+
+    try:
+        import scitex as stx
+        from scitex.plt.styles.presets import SCITEX_STYLE
+
+        # Create a temporary figure
+        style = SCITEX_STYLE.copy()
+        style["figsize"] = (4, 3)
+        fig, ax = stx.plt.subplots(**style)
+
+        # Generate plot
+        plot_func = PLOT_FUNCTIONS[plot_name]
+        fig, ax = plot_func(fig, ax, stx)
+
+        # Export to CSV and parse
+        csv_buffer = io.StringIO()
+        ax.export_as_csv(csv_buffer)
+        csv_buffer.seek(0)
+
+        import pandas as pd
+        df = pd.read_csv(csv_buffer)
+
+        # Close figure
+        stx.plt.close(fig._fig_mpl if hasattr(fig, "_fig_mpl") else fig)
+
+        return df
+
+    except Exception as e:
+        # Some plots may not have exportable CSV data
+        import warnings
+        warnings.warn(f"Could not get data for {category}/{plot_name}: {e}")
+        return None
+
 
-__all__ = ["generate", "list_plots", "CATEGORIES"]
+__all__ = ["generate", "list_plots", "CATEGORIES", "get_plot_spec", "get_plot_data"]
 
 # EOF

scitex/plt/styles/_plot_postprocess.py

@@ -119,7 +119,9 @@ def _apply_tick_locator(ax):
     try:
 
         def is_categorical_axis(axis):
-            if isinstance(axis.converter, StrCategoryConverter):
+            # Use get_converter() for matplotlib 3.10+ compatibility
+            converter = getattr(axis, 'get_converter', lambda: axis.converter)()
+            if isinstance(converter, StrCategoryConverter):
                 return True
             if hasattr(axis, "units") and isinstance(axis.units, UnitData):
                 return True

scitex/plt/utils/_configure_mpl.py

@@ -9,11 +9,14 @@ from typing import Dict
 from typing import Optional
 from typing import Tuple
 
+import logging
 import matplotlib.pyplot as plt
 import numpy as np
 import scitex
 from scitex.dict import DotDict
 
+logger = logging.getLogger(__name__)
+
 
 def configure_mpl(
     plt,
@@ -343,28 +346,22 @@ def configure_mpl(
     plt.rcParams.update(mpl_config)
 
     if verbose:
-        print("\n" + "-" * 40)
-        print("Matplotlib has been configured as follows:\n")
-        print(f"Figure DPI (Display): {dpi_display} DPI")
-        print(f"Figure DPI (Save): {dpi_save} DPI")
-        print(
+        colors_str = "\n".join(f"  {color_str}: {rgba}" for color_str, rgba in RGBA.items())
+        config_msg = (
+            f"\n{'-' * 40}\n"
+            f"Matplotlib has been configured as follows:\n\n"
+            f"Figure DPI (Display): {dpi_display} DPI\n"
+            f"Figure DPI (Save): {dpi_save} DPI\n"
             f"Figure Size (Not the Axis Size): "
             f"{fig_size_mm[0] * fig_scale:.1f} x "
-            f"{fig_size_mm[1] * fig_scale:.1f} mm (width x height)"
+            f"{fig_size_mm[1] * fig_scale:.1f} mm (width x height)\n"
+            f"\nHide Top and Right Axes: {hide_top_right_spines}\n"
+            f"Line Width: {line_width}\n"
+            f"\nCustom Colors (RGBA):\n"
+            f"{colors_str}\n"
+            f"{'-' * 40}"
         )
-        # print("\nFont Sizes:")
-        # print(f"  Base Size: {base_size:.1f}pt")
-        # print(f"  Title: {title_size:.1f}pt (125% of base, min 10pt)")
-        # print(f"  Axis Labels: {label_size:.1f}pt (100% of base, min 9pt)")
-        # print(f"  Tick Labels: {small_size:.1f}pt (85% of base, min 8pt)")
-        # print(f"  Legend: {small_size:.1f}pt (85% of base, min 8pt)")
-        print(f"\nHide Top and Right Axes: {hide_top_right_spines}")
-        print(f"Line Width: {line_width}")
-        # print(f"Number of Ticks: {n_ticks}")
-        print(f"\nCustom Colors (RGBA):")
-        for color_str, rgba in RGBA.items():
-            print(f"  {color_str}: {rgba}")
-        print("-" * 40)
+        logger.info(config_msg)
 
     # Store n_ticks for later use
     plt._n_ticks = n_ticks

scitex/repro/_RandomStateManager.py

@@ -1,9 +1,9 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Timestamp: "2025-12-09 (ywatanabe)"
 # File: /home/ywatanabe/proj/scitex-code/src/scitex/repro/_RandomStateManager.py
 # ----------------------------------------
 from __future__ import annotations
+
 import os
 
 __FILE__ = __file__
@@ -21,6 +21,7 @@ Main API:
 
 import hashlib
 import json
+import logging
 import pickle
 from contextlib import contextmanager
 from pathlib import Path
@@ -28,6 +29,8 @@ from typing import Any
 
 from scitex.config import get_paths
 
+logger = logging.getLogger(__name__)
+
 # Global singleton instance
 _GLOBAL_INSTANCE = None
 
@@ -62,7 +65,7 @@ class RandomStateManager:
         self._jax_key = None  # Initialize to None, will be set if jax is available
 
         if verbose:
-            print(f"RandomStateManager initialized with seed {seed}")
+            logger.info(f"RandomStateManager initialized with seed {seed}")
 
         # Auto-fix all available seeds
         self._auto_fix_seeds(verbose=verbose)
@@ -138,7 +141,7 @@ class RandomStateManager:
             pass
 
         if verbose and fixed_modules:
-            print(f"Fixed random seeds for: {', '.join(fixed_modules)}")
+            logger.info(f"Fixed random seeds for: {', '.join(fixed_modules)}")
 
     def get_np_generator(self, name: str):
         """
@@ -225,7 +228,6 @@ class RandomStateManager:
         >>> # Next run:
         >>> rng.verify(data, "train_data")  # Verifies match
         """
-        import numpy as np
 
         # Auto-generate name if needed
         if name is None:
@@ -249,7 +251,7 @@ class RandomStateManager:
 
         # Check cache
         if cache_file.exists():
-            with open(cache_file, "r") as f:
+            with open(cache_file) as f:
                 cached = json.load(f)
 
             matches = cached["hash"] == obj_hash
@@ -315,7 +317,10 @@ class RandomStateManager:
             if isinstance(obj, jnp.ndarray):
                 obj_np = np.array(obj)
                 return hashlib.sha256(obj_np.tobytes()).hexdigest()[:32]
-        except ImportError:
+        except (ImportError, AttributeError, RuntimeError):
+            # ImportError: jax not installed
+            # AttributeError: circular import in jax._src.clusters
+            # RuntimeError: other jax initialization errors
             pass
 
         # Pandas DataFrame/Series
@@ -504,7 +509,6 @@ class RandomStateManager:
         >>> rng.clear_cache(["test1", "test2"])  # Clear multiple
         >>> rng.clear_cache("experiment_*")  # Clear pattern
         """
-        import glob
 
         if not self._cache_dir.exists():
             return 0
@@ -614,7 +618,6 @@ def main(args):
     - Reproducible random generation
     - Verification of reproducibility
     """
-    import numpy as np
 
     # Create RandomStateManager (already created by session.start)
     print(f"\n{'=' * 60}")
@@ -650,7 +653,9 @@ def main(args):
 
 if __name__ == "__main__":
     import sys
+
     import matplotlib.pyplot as plt
+
     import scitex as stx
 
     args = parse_args()

scitex/resource/__init__.py

@@ -2,7 +2,17 @@
 """Scitex resource module."""
 
 from ._get_processor_usages import get_processor_usages
-from ._get_specs import get_specs
+from ._get_specs import (
+    _cpu_info,
+    _disk_info,
+    _memory_info,
+    _network_info,
+    _supple_nvidia_info,
+    _supple_os_info,
+    _supple_python_info,
+    _system_info,
+    get_specs,
+)
 from ._log_processor_usages import log_processor_usages, main
 
 __all__ = [
@@ -10,4 +20,12 @@ __all__ = [
     "get_specs",
     "log_processor_usages",
     "main",
+    "_cpu_info",
+    "_disk_info",
+    "_memory_info",
+    "_network_info",
+    "_supple_nvidia_info",
+    "_supple_os_info",
+    "_supple_python_info",
+    "_system_info",
 ]