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

scitex/fts/_fig/_models/_plot_types/_image.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+# Timestamp: 2025-12-20
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/fsb/_fig/_models/_plot_types/_image.py
+
+"""Image and heatmap configurations."""
+
+from dataclasses import dataclass
+from typing import Any, List, Optional, Union
+
+
+@dataclass
+class ImshowConfig:
+    """Image display configuration."""
+
+    img: Any
+    cmap: Optional[str] = "viridis"
+    aspect: str = "auto"
+    interpolation: Optional[str] = None
+    vmin: Optional[float] = None
+    vmax: Optional[float] = None
+    origin: str = "upper"
+    id: Optional[str] = None
+
+
+@dataclass
+class ContourConfig:
+    """Contour plot configuration."""
+
+    x: List[float]
+    y: List[float]
+    z: Any
+    levels: Optional[Union[int, List[float]]] = None
+    filled: bool = False
+    cmap: Optional[str] = None
+    colors: Optional[str] = None
+    linewidths: Optional[float] = None
+    alpha: Optional[float] = None
+    vmin: Optional[float] = None
+    vmax: Optional[float] = None
+    id: Optional[str] = None
+
+
+@dataclass
+class HeatmapConfig:
+    """Heatmap configuration (scitex.plt.ax.stx_heatmap)."""
+
+    data: Any
+    x_labels: Optional[List[str]] = None
+    y_labels: Optional[List[str]] = None
+    cbar_label: Optional[str] = None
+    cmap: str = "viridis"
+    vmin: Optional[float] = None
+    vmax: Optional[float] = None
+    show_annot: bool = False
+    value_format: str = "{x:.2f}"
+    id: Optional[str] = None
+
+
+__all__ = ["ImshowConfig", "ContourConfig", "HeatmapConfig"]
+
+# EOF

scitex/fts/_fig/_models/_plot_types/_line.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+# Timestamp: 2025-12-20
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/fsb/_fig/_models/_plot_types/_line.py
+
+"""Line plot configurations."""
+
+from dataclasses import dataclass
+from typing import List, Optional
+
+
+@dataclass
+class LinePlotConfig:
+    """Line plot configuration."""
+
+    x: List[float]
+    y: List[float]
+    color: Optional[str] = None
+    linewidth: Optional[float] = None
+    linestyle: Optional[str] = "-"
+    marker: Optional[str] = None
+    markersize: Optional[float] = None
+    alpha: Optional[float] = None
+    label: Optional[str] = None
+    id: Optional[str] = None
+
+
+@dataclass
+class PlotLineConfig:
+    """Plot line configuration (scitex.plt.ax.stx_line)."""
+
+    y: List[float]
+    x: Optional[List[float]] = None
+    color: Optional[str] = None
+    linewidth_mm: Optional[float] = None
+    linestyle: Optional[str] = "-"
+    label: Optional[str] = None
+    id: Optional[str] = None
+
+
+@dataclass
+class ShadedLineConfig:
+    """Shaded line configuration (scitex.plt.ax.stx_shaded_line)."""
+
+    x: List[float]
+    y_lower: List[float]
+    y_middle: List[float]
+    y_upper: List[float]
+    color: Optional[str] = None
+    alpha: Optional[float] = 0.3
+    linewidth_mm: Optional[float] = None
+    label: Optional[str] = None
+    id: Optional[str] = None
+
+
+__all__ = ["LinePlotConfig", "PlotLineConfig", "ShadedLineConfig"]
+
+# EOF

scitex/fts/_fig/_models/_plot_types/_scatter.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+# Timestamp: 2025-12-20
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/fsb/_fig/_models/_plot_types/_scatter.py
+
+"""Scatter plot configurations."""
+
+from dataclasses import dataclass
+from typing import List, Optional, Union
+
+
+@dataclass
+class ScatterPlotConfig:
+    """Scatter plot configuration."""
+
+    x: List[float]
+    y: List[float]
+    color: Optional[str] = None
+    size_mm: Optional[float] = None
+    s: Optional[float] = None
+    marker: Optional[str] = "o"
+    alpha: Optional[float] = None
+    cmap: Optional[str] = None
+    c: Optional[Union[str, List[float]]] = None
+    label: Optional[str] = None
+    id: Optional[str] = None
+
+
+__all__ = ["ScatterPlotConfig"]
+
+# EOF

scitex/fts/_fig/_models/_plot_types/_seaborn.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+# Timestamp: 2025-12-20
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/fsb/_fig/_models/_plot_types/_seaborn.py
+
+"""Seaborn plot configurations."""
+
+from dataclasses import dataclass
+from typing import Any, Optional, Union
+
+
+@dataclass
+class SeabornBoxplotConfig:
+    """Seaborn boxplot configuration."""
+
+    x: Optional[str] = None
+    y: Optional[str] = None
+    data: Optional[Any] = None
+    hue: Optional[str] = None
+    palette: Optional[str] = None
+    id: Optional[str] = None
+
+
+@dataclass
+class SeabornViolinplotConfig:
+    """Seaborn violinplot configuration."""
+
+    x: Optional[str] = None
+    y: Optional[str] = None
+    data: Optional[Any] = None
+    hue: Optional[str] = None
+    palette: Optional[str] = None
+    id: Optional[str] = None
+
+
+@dataclass
+class SeabornScatterplotConfig:
+    """Seaborn scatterplot configuration."""
+
+    x: Optional[str] = None
+    y: Optional[str] = None
+    data: Optional[Any] = None
+    hue: Optional[str] = None
+    size: Optional[str] = None
+    style: Optional[str] = None
+    palette: Optional[str] = None
+    id: Optional[str] = None
+
+
+@dataclass
+class SeabornLineplotConfig:
+    """Seaborn lineplot configuration."""
+
+    x: Optional[str] = None
+    y: Optional[str] = None
+    data: Optional[Any] = None
+    hue: Optional[str] = None
+    style: Optional[str] = None
+    palette: Optional[str] = None
+    id: Optional[str] = None
+
+
+@dataclass
+class SeabornHistplotConfig:
+    """Seaborn histplot configuration."""
+
+    x: Optional[str] = None
+    data: Optional[Any] = None
+    hue: Optional[str] = None
+    bins: Union[int, str] = "auto"
+    kde: bool = False
+    alpha: Optional[float] = None
+    id: Optional[str] = None
+
+
+@dataclass
+class SeabornBarplotConfig:
+    """Seaborn barplot configuration."""
+
+    x: Optional[str] = None
+    y: Optional[str] = None
+    data: Optional[Any] = None
+    hue: Optional[str] = None
+    palette: Optional[str] = None
+    estimator: str = "mean"
+    id: Optional[str] = None
+
+
+@dataclass
+class SeabornStripplotConfig:
+    """Seaborn stripplot configuration."""
+
+    x: Optional[str] = None
+    y: Optional[str] = None
+    data: Optional[Any] = None
+    hue: Optional[str] = None
+    alpha: Optional[float] = None
+    id: Optional[str] = None
+
+
+@dataclass
+class SeabornKDEplotConfig:
+    """Seaborn KDE plot configuration."""
+
+    x: Optional[str] = None
+    data: Optional[Any] = None
+    hue: Optional[str] = None
+    fill: bool = False
+
+
+__all__ = [
+    "SeabornBoxplotConfig",
+    "SeabornViolinplotConfig",
+    "SeabornScatterplotConfig",
+    "SeabornLineplotConfig",
+    "SeabornHistplotConfig",
+    "SeabornBarplotConfig",
+    "SeabornStripplotConfig",
+    "SeabornKDEplotConfig",
+]
+
+# EOF

scitex/fts/_fig/_models/_plot_types/_violin.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+# Timestamp: 2025-12-20
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/fsb/_fig/_models/_plot_types/_violin.py
+
+"""Violin plot configurations."""
+
+from dataclasses import dataclass
+from typing import List, Optional
+
+
+@dataclass
+class ViolinPlotConfig:
+    """Violin plot configuration."""
+
+    data: List[List[float]]
+    positions: Optional[List[float]] = None
+    widths: Optional[float] = 0.5
+    showmeans: bool = False
+    showmedians: bool = False
+    showextrema: bool = True
+    id: Optional[str] = None
+
+
+@dataclass
+class ViolinConfig:
+    """Violin plot configuration (scitex.plt.ax.stx_violin)."""
+
+    data: List[List[float]]
+    labels: Optional[List[str]] = None
+    colors: Optional[List[str]] = None
+    id: Optional[str] = None
+
+
+__all__ = ["ViolinPlotConfig", "ViolinConfig"]
+
+# EOF

scitex/fts/_fig/_utils/__init__.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+# Timestamp: 2025-12-20
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/fsb/_fig/_utils/__init__.py
+
+"""Utilities for FTS figures - layout, defaults, validation."""
+
+# Constants
+from ._const_sizes import (
+    A4_HEIGHT_MM,
+    A4_WIDTH_MM,
+    CELL_DOUBLE_COLUMN_MM,
+    CELL_SINGLE_COLUMN_MM,
+    DEFAULT_MARGIN_MM,
+    DEFAULT_SPACING_MM,
+    NATURE_DOUBLE_COLUMN_MM,
+    NATURE_FULL_PAGE_MM,
+    NATURE_SINGLE_COLUMN_MM,
+    PNAS_DOUBLE_COLUMN_MM,
+    PNAS_SINGLE_COLUMN_MM,
+    SCIENCE_DOUBLE_COLUMN_MM,
+    SCIENCE_SINGLE_COLUMN_MM,
+)
+
+# Templates
+from ._get_template import (
+    TEMPLATES,
+    get_a4_figure,
+    get_nature_double_column,
+    get_nature_single_column,
+    get_presentation_slide,
+    get_science_single_column,
+    get_square_figure,
+    get_template,
+    list_templates,
+)
+
+# Normalization utilities
+from ._normalize import (
+    DEFAULT_POSITION,
+    DEFAULT_SIZE,
+    Position,
+    Size,
+    normalize_position,
+    normalize_size,
+)
+
+# Coordinate conversion
+from ._convert_coords import to_absolute, to_relative
+
+# Bounds calculation
+from ._calc_bounds import (
+    Bounds,
+    content_bounds,
+    element_bounds,
+    validate_within_bounds,
+)
+
+# Auto layout
+from ._auto_layout import auto_crop_layout, auto_layout_grid
+
+# Layout visualization
+from ._plot_layout import BLUEPRINT_STYLE, plot_auto_crop_comparison, plot_layout
+
+# Validation
+from ._validate import (
+    check_schema_version,
+    validate_axes_layout,
+    validate_color,
+    validate_json_structure,
+    validate_plot_data,
+)
+
+__all__ = [
+    # Constants
+    "NATURE_SINGLE_COLUMN_MM",
+    "NATURE_DOUBLE_COLUMN_MM",
+    "NATURE_FULL_PAGE_MM",
+    "SCIENCE_SINGLE_COLUMN_MM",
+    "SCIENCE_DOUBLE_COLUMN_MM",
+    "CELL_SINGLE_COLUMN_MM",
+    "CELL_DOUBLE_COLUMN_MM",
+    "PNAS_SINGLE_COLUMN_MM",
+    "PNAS_DOUBLE_COLUMN_MM",
+    "A4_WIDTH_MM",
+    "A4_HEIGHT_MM",
+    "DEFAULT_MARGIN_MM",
+    "DEFAULT_SPACING_MM",
+    # Templates
+    "get_nature_single_column",
+    "get_nature_double_column",
+    "get_science_single_column",
+    "get_a4_figure",
+    "get_square_figure",
+    "get_presentation_slide",
+    "get_template",
+    "list_templates",
+    "TEMPLATES",
+    # Type aliases
+    "Position",
+    "Size",
+    "Bounds",
+    "DEFAULT_POSITION",
+    "DEFAULT_SIZE",
+    # Normalization
+    "normalize_position",
+    "normalize_size",
+    # Coordinate conversion
+    "to_absolute",
+    "to_relative",
+    # Bounds calculation
+    "element_bounds",
+    "content_bounds",
+    "validate_within_bounds",
+    # Auto layout
+    "auto_layout_grid",
+    "auto_crop_layout",
+    # Layout visualization
+    "plot_layout",
+    "plot_auto_crop_comparison",
+    "BLUEPRINT_STYLE",
+    # Validation
+    "validate_json_structure",
+    "validate_plot_data",
+    "check_schema_version",
+    "validate_color",
+    "validate_axes_layout",
+]
+
+# EOF

scitex/fts/_fig/_utils/_auto_layout.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+# Timestamp: 2025-12-20
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/fsb/_fig/_utils/_auto_layout.py
+
+"""Auto layout utilities for FTS elements."""
+
+from typing import Any, Dict, List, Optional, Tuple
+
+from ._calc_bounds import content_bounds
+from ._normalize import Position, Size, normalize_position, normalize_size
+
+
+def auto_layout_grid(
+    n_elements: int,
+    container_size: Size,
+    margin_mm: float = 5.0,
+    spacing_mm: float = 5.0,
+    max_cols: Optional[int] = None,
+) -> List[Tuple[Position, Size]]:
+    """Generate grid layout positions and sizes for n elements.
+
+    Args:
+        n_elements: Number of elements to layout
+        container_size: Container size
+        margin_mm: Margin from container edges
+        spacing_mm: Spacing between elements
+        max_cols: Maximum columns (None = auto)
+
+    Returns:
+        List of (position, size) tuples for each element
+
+    Example:
+        >>> layouts = auto_layout_grid(4, {"width_mm": 170, "height_mm": 120})
+        >>> len(layouts)
+        4
+    """
+    if n_elements <= 0:
+        return []
+
+    container = normalize_size(container_size)
+
+    # Determine grid dimensions
+    if max_cols is None:
+        cols = min(n_elements, 2)  # Default: max 2 columns
+    else:
+        cols = min(n_elements, max_cols)
+    rows = (n_elements + cols - 1) // cols
+
+    # Calculate element size
+    available_width = container["width_mm"] - 2 * margin_mm - (cols - 1) * spacing_mm
+    available_height = container["height_mm"] - 2 * margin_mm - (rows - 1) * spacing_mm
+    elem_width = available_width / cols
+    elem_height = available_height / rows
+
+    results = []
+    for i in range(n_elements):
+        row = i // cols
+        col = i % cols
+
+        pos: Position = {
+            "x_mm": margin_mm + col * (elem_width + spacing_mm),
+            "y_mm": margin_mm + row * (elem_height + spacing_mm),
+        }
+        size: Size = {
+            "width_mm": elem_width,
+            "height_mm": elem_height,
+        }
+        results.append((pos, size))
+
+    return results
+
+
+def auto_crop_layout(
+    elements: List[Dict[str, Any]],
+    margin_mm: float = 5.0,
+) -> Tuple[List[Dict[str, Any]], Size]:
+    """Calculate auto-cropped layout by shifting elements and resizing canvas.
+
+    This function:
+    1. Finds the bounding box of all elements
+    2. Shifts all positions so content starts at (margin, margin)
+    3. Calculates new canvas size to fit content + margin
+
+    Args:
+        elements: List of element specifications (not modified in place)
+        margin_mm: Margin to add around content (default: 5mm)
+
+    Returns:
+        Tuple of (shifted_elements, new_canvas_size)
+        - shifted_elements: New list with adjusted positions
+        - new_canvas_size: {"width_mm", "height_mm"} for the cropped canvas
+    """
+    if not elements:
+        return [], {"width_mm": margin_mm * 2, "height_mm": margin_mm * 2}
+
+    # Calculate content bounding box
+    bounds = content_bounds(elements)
+    if bounds is None:
+        return [], {"width_mm": margin_mm * 2, "height_mm": margin_mm * 2}
+
+    # Calculate offset to shift content to (margin, margin)
+    offset_x = bounds["x_mm"] - margin_mm
+    offset_y = bounds["y_mm"] - margin_mm
+
+    # Shift all element positions
+    shifted_elements = []
+    for elem in elements:
+        shifted = elem.copy()
+        pos = normalize_position(elem.get("position"))
+        shifted["position"] = {
+            "x_mm": pos["x_mm"] - offset_x,
+            "y_mm": pos["y_mm"] - offset_y,
+        }
+        shifted_elements.append(shifted)
+
+    # Calculate new canvas size
+    new_size: Size = {
+        "width_mm": bounds["width_mm"] + margin_mm * 2,
+        "height_mm": bounds["height_mm"] + margin_mm * 2,
+    }
+
+    return shifted_elements, new_size
+
+
+__all__ = ["auto_layout_grid", "auto_crop_layout"]
+
+# EOF

scitex/fts/_fig/_utils/_calc_bounds.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+# Timestamp: 2025-12-20
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/fsb/_fig/_utils/_calc_bounds.py
+
+"""Bounding box calculation utilities for FTS elements."""
+
+from typing import Any, Dict, List, Optional
+
+from ._normalize import Size, normalize_position, normalize_size
+
+# Type alias
+Bounds = Dict[str, float]  # {"x_mm", "y_mm", "width_mm", "height_mm"}
+
+
+def element_bounds(element: Dict[str, Any]) -> Bounds:
+    """Get element bounding box.
+
+    Args:
+        element: Element specification with position and size
+
+    Returns:
+        Bounding box {x_mm, y_mm, width_mm, height_mm}
+    """
+    pos = normalize_position(element.get("position"))
+    size = normalize_size(element.get("size"))
+    return {
+        "x_mm": pos["x_mm"],
+        "y_mm": pos["y_mm"],
+        "width_mm": size["width_mm"],
+        "height_mm": size["height_mm"],
+    }
+
+
+def content_bounds(elements: List[Dict[str, Any]]) -> Optional[Bounds]:
+    """Calculate the bounding box containing all elements.
+
+    Args:
+        elements: List of element specifications
+
+    Returns:
+        Bounding box {"x_mm", "y_mm", "width_mm", "height_mm"}
+        containing all elements, or None if no elements.
+    """
+    if not elements:
+        return None
+
+    min_x = float("inf")
+    min_y = float("inf")
+    max_x = float("-inf")
+    max_y = float("-inf")
+
+    for elem in elements:
+        bounds = element_bounds(elem)
+
+        # Update min/max coordinates
+        min_x = min(min_x, bounds["x_mm"])
+        min_y = min(min_y, bounds["y_mm"])
+        max_x = max(max_x, bounds["x_mm"] + bounds["width_mm"])
+        max_y = max(max_y, bounds["y_mm"] + bounds["height_mm"])
+
+    return {
+        "x_mm": min_x,
+        "y_mm": min_y,
+        "width_mm": max_x - min_x,
+        "height_mm": max_y - min_y,
+    }
+
+
+def validate_within_bounds(
+    element: Dict[str, Any],
+    container_size: Size,
+    raise_error: bool = False,
+) -> bool:
+    """Check if element fits within container bounds.
+
+    Args:
+        element: Element with position and size
+        container_size: Container size {"width_mm", "height_mm"}
+        raise_error: If True, raise ValueError on violation
+
+    Returns:
+        True if element fits within container
+
+    Raises:
+        ValueError: If raise_error=True and element exceeds bounds
+    """
+    bounds = element_bounds(element)
+    container = normalize_size(container_size)
+
+    # Check bounds
+    fits = (
+        bounds["x_mm"] >= 0
+        and bounds["y_mm"] >= 0
+        and bounds["x_mm"] + bounds["width_mm"] <= container["width_mm"]
+        and bounds["y_mm"] + bounds["height_mm"] <= container["height_mm"]
+    )
+
+    if not fits and raise_error:
+        raise ValueError(
+            f"Element exceeds container bounds: "
+            f"element=({bounds['x_mm']}, {bounds['y_mm']}, "
+            f"{bounds['width_mm']}x{bounds['height_mm']}), "
+            f"container=({container['width_mm']}x{container['height_mm']})"
+        )
+
+    return fits
+
+
+__all__ = ["element_bounds", "content_bounds", "validate_within_bounds", "Bounds"]
+
+# EOF