scitex 2.5.0__py3-none-any.whl → 2.7.0__py3-none-any.whl

scitex/plt/utils/_csv_column_naming.py

@@ -12,19 +12,34 @@ This module ensures consistent column naming between:
 - GUI editors (reading CSV data back)
 
 Column naming convention:
-    ax_{row}{col}_{trace_id}_{data_type}
+    {domain-name-value}_{domain-name-value}_...
+
+    - Underscore (_) separates different domains
+    - Hyphen (-) within domain name and between name-value
+
+Format:
+    ax-row-{row}-col-{col}_trace-id-{trace_id}_variable-{variable}
 
 Where:
-    - row, col: axes position in grid (e.g., "00" for single axes)
-    - trace_id: unique identifier for the trace (from label, id kwarg, or index)
-    - data_type: type of data (e.g., "plot_x", "plot_y", "hist_bins", etc.)
+    - ax-row-{row}-col-{col}: axes position in grid
+    - trace-id-{id}: unique identifier for the trace, which can be:
+        * User-provided id kwarg (e.g., "sine", "my-data")
+        * Generated from label (e.g., "sin-x" from "sin(x)")
+        * Auto-generated index (e.g., "0", "1")
+    - variable-{var}: type of data variable (e.g., "x", "y", "bins", "heights")
+
+Examples:
+    ax-row-0-col-0_trace-id-sine_variable-x       (row 0, col 0, id "sine", x)
+    ax-row-0-col-0_trace-id-sine_variable-y       (row 0, col 0, id "sine", y)
+    ax-row-0-col-1_trace-id-0_variable-x          (row 0, col 1, auto id 0, x)
+    ax-row-1-col-0_trace-id-my-data_variable-bins (row 1, col 0, "my-data", bins)
 """
 
 __all__ = [
-    'get_csv_column_name',
-    'get_csv_column_prefix',
-    'parse_csv_column_name',
-    'sanitize_trace_id',
+    "get_csv_column_name",
+    "get_csv_column_prefix",
+    "parse_csv_column_name",
+    "sanitize_trace_id",
 ]
 
 
@@ -32,6 +47,7 @@ def sanitize_trace_id(trace_id: str) -> str:
     """Sanitize trace ID for use in CSV column names.
 
     Removes or replaces characters that could cause issues in column names.
+    Uses hyphen (-) for word separation within values.
 
     Parameters
     ----------
@@ -42,36 +58,48 @@ def sanitize_trace_id(trace_id: str) -> str:
     -------
     str
         Sanitized trace ID safe for CSV column names
+
+    Examples
+    --------
+    >>> sanitize_trace_id("sin(x)")
+    'sin-x'
+    >>> sanitize_trace_id("My Data")
+    'my-data'
     """
     if not trace_id:
         return "unnamed"
 
-    # Replace problematic characters
-    sanitized = str(trace_id)
-    # Keep alphanumeric, underscore, hyphen; replace others with underscore
+    # Replace problematic characters with hyphen (word separator within values)
+    sanitized = str(trace_id).lower()
     result = []
     for char in sanitized:
-        if char.isalnum() or char in ('_', '-'):
+        if char.isalnum():
             result.append(char)
-        elif char in (' ', '(', ')', '[', ']', '{', '}', '/', '\\', '.'):
-            result.append('_')
+        elif char in (" ", "_", "(", ")", "[", "]", "{", "}", "/", "\\", ".", "-"):
+            result.append("-")
         # Skip other characters
 
-    sanitized = ''.join(result)
+    sanitized = "".join(result)
 
-    # Remove consecutive underscores
-    while '__' in sanitized:
-        sanitized = sanitized.replace('__', '_')
+    # Remove consecutive hyphens
+    while "--" in sanitized:
+        sanitized = sanitized.replace("--", "-")
 
-    # Remove leading/trailing underscores
-    sanitized = sanitized.strip('_')
+    # Remove leading/trailing hyphens
+    sanitized = sanitized.strip("-")
 
     return sanitized if sanitized else "unnamed"
 
 
-def get_csv_column_prefix(ax_row: int = 0, ax_col: int = 0, trace_id: str = None, trace_index: int = None) -> str:
+def get_csv_column_prefix(
+    ax_row: int = 0, ax_col: int = 0, trace_id: str = None, trace_index: int = None
+) -> str:
     """Get CSV column prefix for a trace.
 
+    Format: ax-row-{row}-col-{col}_trace-id-{id}_variable-
+    - Underscore (_) separates domains
+    - Hyphen (-) within domain names and between name-value
+
     Parameters
     ----------
     ax_row : int
@@ -86,22 +114,27 @@ def get_csv_column_prefix(ax_row: int = 0, ax_col: int = 0, trace_id: str = None
     Returns
     -------
     str
-        Column prefix like "ax_00_sin_x_" or "ax_01_plot_0_"
-    """
-    ax_pos = f"{ax_row}{ax_col}"
+        Column prefix like "ax-row-0-col-0_trace-id-sine_variable-"
 
+    Examples
+    --------
+    >>> get_csv_column_prefix(trace_id="sine")
+    'ax-row-0-col-0_trace-id-sine_variable-'
+    >>> get_csv_column_prefix(ax_row=1, ax_col=2, trace_index=0)
+    'ax-row-1-col-2_trace-id-0_variable-'
+    """
     if trace_id:
         safe_id = sanitize_trace_id(trace_id)
     elif trace_index is not None:
-        safe_id = f"plot_{trace_index}"
+        safe_id = str(trace_index)
     else:
-        safe_id = "plot_0"
+        safe_id = "0"
 
-    return f"ax_{ax_pos}_{safe_id}_"
+    return f"ax-row-{ax_row}-col-{ax_col}_trace-id-{safe_id}_variable-"
 
 
 def get_csv_column_name(
-    data_type: str,
+    variable: str,
     ax_row: int = 0,
     ax_col: int = 0,
     trace_id: str = None,
@@ -109,10 +142,14 @@ def get_csv_column_name(
 ) -> str:
     """Get full CSV column name for a data field.
 
+    Format: ax-row-{row}-col-{col}_trace-id-{id}_variable-{var}
+    - Underscore (_) separates domains
+    - Hyphen (-) within domain names and between name-value
+
     Parameters
     ----------
-    data_type : str
-        Type of data (e.g., "plot_x", "plot_y", "hist_bins", "bar_heights")
+    variable : str
+        Variable name (e.g., "x", "y", "bins", "heights")
     ax_row : int
         Row position of axes in grid (default: 0)
     ax_col : int
@@ -125,26 +162,32 @@ def get_csv_column_name(
     Returns
     -------
     str
-        Full column name like "ax_00_sin_x_plot_x" or "ax_01_plot_0_plot_y"
+        Full column name like "ax-row-0-col-0_trace-id-sine_variable-x"
 
     Examples
     --------
-    >>> get_csv_column_name("plot_x", trace_id="sin(x)")
-    'ax_00_sin_x_plot_x'
-    >>> get_csv_column_name("plot_y", ax_row=1, ax_col=2, trace_index=0)
-    'ax_12_plot_0_plot_y'
+    >>> get_csv_column_name("x", trace_id="sin(x)")
+    'ax-row-0-col-0_trace-id-sin-x_variable-x'
+    >>> get_csv_column_name("y", ax_row=1, ax_col=2, trace_index=0)
+    'ax-row-1-col-2_trace-id-0_variable-y'
     """
     prefix = get_csv_column_prefix(ax_row, ax_col, trace_id, trace_index)
-    return f"{prefix}{data_type}"
+    # Variable names are simple (x, y, bins, etc.)
+    safe_variable = variable.lower()
+    return f"{prefix}{safe_variable}"
 
 
 def parse_csv_column_name(column_name: str) -> dict:
     """Parse CSV column name to extract components.
 
+    Format: ax-row-{row}-col-{col}_trace-id-{id}_variable-{var}
+    - Underscore (_) separates domains
+    - Hyphen (-) within domain names and between name-value
+
     Parameters
     ----------
     column_name : str
-        Full column name (e.g., "ax_00_sin_x_plot_x")
+        Full column name (e.g., "ax-row-0-col-0_trace-id-sine_variable-x")
 
     Returns
     -------
@@ -153,46 +196,51 @@ def parse_csv_column_name(column_name: str) -> dict:
         - ax_row: int
         - ax_col: int
         - trace_id: str
-        - data_type: str
+        - variable: str
         - valid: bool (True if parsing succeeded)
 
     Examples
     --------
-    >>> parse_csv_column_name("ax_00_sin_x_plot_x")
-    {'ax_row': 0, 'ax_col': 0, 'trace_id': 'sin_x', 'data_type': 'plot_x', 'valid': True}
+    >>> parse_csv_column_name("ax-row-0-col-0_trace-id-sine_variable-x")
+    {'ax_row': 0, 'ax_col': 0, 'trace_id': 'sine', 'variable': 'x', 'valid': True}
+    >>> parse_csv_column_name("ax-row-1-col-2_trace-id-my-data_variable-bins")
+    {'ax_row': 1, 'ax_col': 2, 'trace_id': 'my-data', 'variable': 'bins', 'valid': True}
     """
     result = {
-        'ax_row': 0,
-        'ax_col': 0,
-        'trace_id': '',
-        'data_type': '',
-        'valid': False,
+        "ax_row": 0,
+        "ax_col": 0,
+        "trace_id": "",
+        "variable": "",
+        "valid": False,
     }
 
-    if not column_name or not column_name.startswith('ax_'):
-        return result
-
-    parts = column_name.split('_')
-    if len(parts) < 4:
+    if not column_name or not column_name.startswith("ax-row-"):
         return result
 
     try:
-        # Parse ax position (e.g., "00" from "ax_00_...")
-        ax_pos = parts[1]
-        if len(ax_pos) >= 2:
-            result['ax_row'] = int(ax_pos[0])
-            result['ax_col'] = int(ax_pos[1])
-
-        # Last two parts are typically data_type (e.g., "plot_x", "hist_bins")
-        # Everything in between is the trace_id
-        data_type_parts = parts[-2:]  # e.g., ["plot", "x"]
-        result['data_type'] = '_'.join(data_type_parts)
-
-        # Trace ID is everything between ax_pos and data_type
-        trace_parts = parts[2:-2]
-        result['trace_id'] = '_'.join(trace_parts) if trace_parts else 'plot_0'
-
-        result['valid'] = True
+        # Split by underscore to get domain groups
+        parts = column_name.split("_")
+        # Expected: ["ax-row-0-col-0", "trace-id-sine", "variable-x"]
+
+        for part in parts:
+            if part.startswith("ax-row-"):
+                # Parse ax-row-{row}-col-{col}
+                # Remove "ax-row-" prefix and split by "-col-"
+                rest = part[7:]  # Remove "ax-row-"
+                if "-col-" in rest:
+                    row_str, col_str = rest.split("-col-")
+                    result["ax_row"] = int(row_str)
+                    result["ax_col"] = int(col_str)
+            elif part.startswith("trace-id-"):
+                # Extract trace id (everything after "trace-id-")
+                result["trace_id"] = part[9:]
+            elif part.startswith("variable-"):
+                # Extract variable (everything after "variable-")
+                result["variable"] = part[9:]
+
+        # Validate we got all required fields
+        if result["variable"]:
+            result["valid"] = True
 
     except (ValueError, IndexError):
         pass
@@ -200,7 +248,9 @@ def parse_csv_column_name(column_name: str) -> dict:
     return result
 
 
-def get_trace_columns_from_df(df, trace_id: str = None, trace_index: int = None, ax_row: int = 0, ax_col: int = 0) -> dict:
+def get_trace_columns_from_df(
+    df, trace_id: str = None, trace_index: int = None, ax_row: int = 0, ax_col: int = 0
+) -> dict:
     """Find CSV columns for a specific trace in a DataFrame.
 
     Parameters
@@ -219,17 +269,18 @@ def get_trace_columns_from_df(df, trace_id: str = None, trace_index: int = None,
     Returns
     -------
     dict
-        Dictionary mapping data types to column names, e.g.:
-        {'plot_x': 'ax_00_sin_x_plot_x', 'plot_y': 'ax_00_sin_x_plot_y'}
+        Dictionary mapping variable names to column names, e.g.:
+        {'x': 'ax-row-0-col-0_trace-id-sine_variable-x',
+         'y': 'ax-row-0-col-0_trace-id-sine_variable-y'}
     """
     result = {}
     prefix = get_csv_column_prefix(ax_row, ax_col, trace_id, trace_index)
 
     for col in df.columns:
         if col.startswith(prefix):
-            # Extract data_type from column name
-            data_type = col[len(prefix):]
-            result[data_type] = col
+            # Extract variable from column name
+            variable = col[len(prefix):]
+            result[variable] = col
 
     return result
 

scitex/plt/utils/_dimension_viewer.py

@@ -23,9 +23,7 @@ import matplotlib.pyplot as plt
 import numpy as np
 
 
-def view_dimensions(
-    fig, ax, show_rulers=True, show_grid=True, output_path=None
-):
+def view_dimensions(fig, ax, show_rulers=True, show_grid=True, output_path=None):
     """
     Create a visual representation of figure/axes dimensions.
 
@@ -242,9 +240,7 @@ def view_dimensions(
             ax_diag.plot([mm, mm], [ruler_y, ruler_y - 1], "k-", lw=0.5)
             if mm % 10 == 0:
                 ax_diag.plot([mm, mm], [ruler_y, ruler_y - 2], "k-", lw=1)
-                ax_diag.text(
-                    mm, ruler_y - 3, f"{mm}", ha="center", fontsize=8
-                )
+                ax_diag.text(mm, ruler_y - 3, f"{mm}", ha="center", fontsize=8)
 
         # Vertical ruler (left)
         ruler_x = -10
@@ -252,9 +248,7 @@ def view_dimensions(
             ax_diag.plot([ruler_x, ruler_x - 1], [mm, mm], "k-", lw=0.5)
             if mm % 10 == 0:
                 ax_diag.plot([ruler_x, ruler_x - 2], [mm, mm], "k-", lw=1)
-                ax_diag.text(
-                    ruler_x - 3, mm, f"{mm}", ha="right", fontsize=8
-                )
+                ax_diag.text(ruler_x - 3, mm, f"{mm}", ha="right", fontsize=8)
 
     # Grid
     if show_grid:
@@ -293,9 +287,7 @@ def view_dimensions(
     return fig_diag
 
 
-def compare_modes(
-    axes_width_mm=30, axes_height_mm=21, output_path=None
-):
+def compare_modes(axes_width_mm=30, axes_height_mm=21, output_path=None):
     """
     Compare publication vs display modes side-by-side.
 
@@ -370,13 +362,11 @@ def compare_modes(
     ax2 = fig_comp.add_subplot(122)
     view_disp = view_dimensions(fig_disp, ax_disp, show_rulers=False)
     ax2.set_title(
-        f"Display Mode\n{axes_width_mm*3}×{axes_height_mm*3} mm @ 100 DPI (3x scaled)",
+        f"Display Mode\n{axes_width_mm * 3}×{axes_height_mm * 3} mm @ 100 DPI (3x scaled)",
         fontweight="bold",
     )
 
-    plt.suptitle(
-        "Mode Comparison: Publication vs Display", fontsize=14, y=0.98
-    )
+    plt.suptitle("Mode Comparison: Publication vs Display", fontsize=14, y=0.98)
     plt.tight_layout()
 
     # Close original figures
@@ -421,9 +411,7 @@ if __name__ == "__main__":
 
     # View dimensions
     print("\n2. Viewing dimensions")
-    fig_diag = view_dimensions(
-        fig, ax, output_path="/tmp/dimension_viewer_demo.png"
-    )
+    fig_diag = view_dimensions(fig, ax, output_path="/tmp/dimension_viewer_demo.png")
 
     # Compare modes
     print("\n3. Comparing publication vs display modes")

scitex/plt/utils/_figure_from_axes_mm.py

@@ -124,9 +124,7 @@ def create_axes_with_size_mm(
         dpi = max(dpi, 300)  # Ensure at least 300 DPI
 
     # Calculate figure size = axes size + margins
-    fig_width_mm = (
-        axes_width_mm + margin_mm.get("left", 0) + margin_mm.get("right", 0)
-    )
+    fig_width_mm = axes_width_mm + margin_mm.get("left", 0) + margin_mm.get("right", 0)
     fig_height_mm = (
         axes_height_mm + margin_mm.get("bottom", 0) + margin_mm.get("top", 0)
     )
@@ -218,14 +216,38 @@ def get_dimension_info(fig, ax) -> Dict:
     fig_width_px = int(fig_width_inch * dpi)
     fig_height_px = int(fig_height_inch * dpi)
 
-    # Axes position and size
-    pos = ax.get_position()  # [left, bottom, width, height] in figure coords
-    axes_width_inch = fig_width_inch * pos.width
-    axes_height_inch = fig_height_inch * pos.height
+    # Draw the figure to finalize layout (constrained_layout, tight_layout, etc.)
+    # This ensures we get the ACTUAL axes position after all adjustments
+    fig.canvas.draw()
+
+    # Get actual axes position using window_extent (actual pixel coordinates)
+    # This accounts for tight_layout, constrained_layout, and label adjustments
+    bbox = ax.get_window_extent()
+
+    # Convert from display coordinates (bottom-left origin) to figure pixels
+    axes_x0_px = int(round(bbox.x0))
+    axes_x1_px = int(round(bbox.x1))
+    # Convert to top-left origin for web/canvas compatibility
+    axes_y0_px = int(round(fig_height_px - bbox.y1))  # Top edge (flipped for web)
+    axes_y1_px = int(round(fig_height_px - bbox.y0))  # Bottom edge (X-axis position)
+
+    axes_width_px = int(round(bbox.width))
+    axes_height_px = int(round(bbox.height))
+
+    # Convert to inches and mm
+    axes_width_inch = bbox.width / dpi
+    axes_height_inch = bbox.height / dpi
     axes_width_mm = inch_to_mm(axes_width_inch)
     axes_height_mm = inch_to_mm(axes_height_inch)
-    axes_width_px = int(axes_width_inch * dpi)
-    axes_height_px = int(axes_height_inch * dpi)
+
+    # Calculate mm coordinates
+    axes_x0_mm = (bbox.x0 / dpi) * MM_PER_INCH
+    axes_x1_mm = (bbox.x1 / dpi) * MM_PER_INCH
+    axes_y0_mm = ((fig_height_px - bbox.y1) / dpi) * MM_PER_INCH  # Top (flipped)
+    axes_y1_mm = ((fig_height_px - bbox.y0) / dpi) * MM_PER_INCH  # Bottom (flipped)
+
+    # Also get normalized position for reference
+    pos = ax.get_position()
 
     return {
         # Figure dimensions
@@ -237,6 +259,26 @@ def get_dimension_info(fig, ax) -> Dict:
         "axes_size_inch": (axes_width_inch, axes_height_inch),
         "axes_size_mm": (axes_width_mm, axes_height_mm),
         "axes_size_px": (axes_width_px, axes_height_px),
+        # Axes bounding box in pixels (for canvas/web alignment, origin top-left)
+        # x0: left edge (Y-axis position), x1: right edge
+        # y0: top edge, y1: bottom edge (X-axis position)
+        "axes_bbox_px": {
+            "x0": axes_x0_px,
+            "y0": axes_y0_px,
+            "x1": axes_x1_px,
+            "y1": axes_y1_px,
+            "width": axes_width_px,
+            "height": axes_height_px,
+        },
+        # Axes bounding box in mm
+        "axes_bbox_mm": {
+            "x0": axes_x0_mm,
+            "y0": axes_y0_mm,
+            "x1": axes_x1_mm,
+            "y1": axes_y1_mm,
+            "width": axes_width_mm,
+            "height": axes_height_mm,
+        },
         # Settings
         "dpi": dpi,
         "mm_per_inch": MM_PER_INCH,
@@ -268,13 +310,23 @@ def print_dimension_info(fig, ax):
     print("=" * 60)
 
     print("\n📐 FIGURE (total canvas including margins):")
-    print(f"  • Size (mm):    {info['figure_size_mm'][0]:.2f} × {info['figure_size_mm'][1]:.2f}")
-    print(f"  • Size (inch):  {info['figure_size_inch'][0]:.3f} × {info['figure_size_inch'][1]:.3f}")
-    print(f"  • Size (px):    {info['figure_size_px'][0]} × {info['figure_size_px'][1]}")
+    print(
+        f"  • Size (mm):    {info['figure_size_mm'][0]:.2f} × {info['figure_size_mm'][1]:.2f}"
+    )
+    print(
+        f"  • Size (inch):  {info['figure_size_inch'][0]:.3f} × {info['figure_size_inch'][1]:.3f}"
+    )
+    print(
+        f"  • Size (px):    {info['figure_size_px'][0]} × {info['figure_size_px'][1]}"
+    )
 
     print("\n📊 AXES (actual plot area):")
-    print(f"  • Size (mm):    {info['axes_size_mm'][0]:.2f} × {info['axes_size_mm'][1]:.2f}")
-    print(f"  • Size (inch):  {info['axes_size_inch'][0]:.3f} × {info['axes_size_inch'][1]:.3f}")
+    print(
+        f"  • Size (mm):    {info['axes_size_mm'][0]:.2f} × {info['axes_size_mm'][1]:.2f}"
+    )
+    print(
+        f"  • Size (inch):  {info['axes_size_inch'][0]:.3f} × {info['axes_size_inch'][1]:.3f}"
+    )
     print(f"  • Size (px):    {info['axes_size_px'][0]} × {info['axes_size_px'][1]}")
     print(
         f"  • Position:     left={info['axes_position'][0]:.3f}, bottom={info['axes_position'][1]:.3f}"
@@ -288,11 +340,13 @@ def print_dimension_info(fig, ax):
     print(f"  • pixels = inches × DPI")
     print(f"  • mm = inches × 25.4")
     print(f"  • At {info['dpi']} DPI:")
-    print(f"    - 1 mm = {info['dpi']/25.4:.2f} pixels")
+    print(f"    - 1 mm = {info['dpi'] / 25.4:.2f} pixels")
     print(f"    - 1 inch = {info['dpi']} pixels")
 
     print("\n📝 FOR PUBLICATION:")
-    print(f"  • Save with: fig.savefig('file.tiff', dpi={info['dpi']}, bbox_inches='tight')")
+    print(
+        f"  • Save with: fig.savefig('file.tiff', dpi={info['dpi']}, bbox_inches='tight')"
+    )
     print(
         f"  • Final size will be approximately {info['axes_size_mm'][0]:.1f} × {info['axes_size_mm'][1]:.1f} mm"
     )

scitex/plt/utils/_figure_mm.py

@@ -135,7 +135,7 @@ def create_figure_ax_mm(
     # Create axes with exact position and transparent background if requested
     ax = fig.add_axes([left, bottom, width, height])
     # Make axes background transparent when figure background is transparent
-    if fig.get_facecolor() == (0, 0, 0, 0) or fig.get_facecolor() == 'none':
+    if fig.get_facecolor() == (0, 0, 0, 0) or fig.get_facecolor() == "none":
         ax.patch.set_alpha(0.0)
 
     # Apply styling if provided
@@ -238,6 +238,7 @@ def apply_style_mm(ax: Axes, style: Dict) -> float:
     if marker_size_mm is not None:
         marker_size_pt = mm_to_pt(marker_size_mm)
         import matplotlib as mpl
+
         mpl.rcParams["lines.markersize"] = marker_size_pt
 
     # Configure tick parameters (all mm values converted to points)
@@ -351,6 +352,6 @@ if __name__ == "__main__":
     output_path = "/tmp/test_mm_control.png"
     fig.savefig(output_path, dpi=300, bbox_inches="tight")
     print(f"Figure saved to: {output_path}")
-    print(f"Physical size: 35 mm × {35*0.7:.1f} mm")
+    print(f"Physical size: 35 mm × {35 * 0.7:.1f} mm")
 
 # EOF

scitex/plt/utils/_get_actual_font.py

@@ -42,14 +42,15 @@ def get_actual_font_name():
 
     # Fallback: extract from filename if not found in font list
     import os
+
     font_filename = os.path.basename(actual_font_path)
     # Remove .ttf extension and try to clean up the name
     font_name = os.path.splitext(font_filename)[0]
     # Capitalize common font names for better readability
-    if font_name.lower() == 'arial':
-        return 'Arial'
-    elif font_name.lower().startswith('dejavusans'):
-        return 'DejaVu Sans'
+    if font_name.lower() == "arial":
+        return "Arial"
+    elif font_name.lower().startswith("dejavusans"):
+        return "DejaVu Sans"
     return font_name