scitex 2.10.3__py3-none-any.whl → 2.13.0__py3-none-any.whl

scitex/fts/_kinds/_plot/_utils/_const_sizes.py

@@ -1,48 +0,0 @@
-#!/usr/bin/env python3
-# Timestamp: 2025-12-20
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/fsb/_fig/_utils/_const_sizes.py
-
-"""Journal and publication figure size constants (mm)."""
-
-# Nature
-NATURE_SINGLE_COLUMN_MM = 89
-NATURE_DOUBLE_COLUMN_MM = 183
-NATURE_FULL_PAGE_MM = 247
-
-# Science
-SCIENCE_SINGLE_COLUMN_MM = 84
-SCIENCE_DOUBLE_COLUMN_MM = 174
-
-# Cell
-CELL_SINGLE_COLUMN_MM = 85
-CELL_DOUBLE_COLUMN_MM = 174
-
-# PNAS
-PNAS_SINGLE_COLUMN_MM = 87
-PNAS_DOUBLE_COLUMN_MM = 178
-
-# A4 page
-A4_WIDTH_MM = 210
-A4_HEIGHT_MM = 297
-
-# Default spacing
-DEFAULT_MARGIN_MM = 5
-DEFAULT_SPACING_MM = 3
-
-__all__ = [
-    "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",
-]
-
-# EOF

scitex/fts/_kinds/_plot/_utils/_convert_coords.py

@@ -1,77 +0,0 @@
-#!/usr/bin/env python3
-# Timestamp: 2025-12-20
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/fsb/_fig/_utils/_convert_coords.py
-
-"""Coordinate conversion utilities for FTS layout.
-
-Coordinate System:
-- Origin (0,0) is at TOP-LEFT corner
-- x_mm increases to the RIGHT
-- y_mm increases DOWNWARD
-"""
-
-from typing import Dict, Optional
-
-from ._normalize import normalize_position
-
-# Type alias
-Position = Dict[str, float]  # {"x_mm": float, "y_mm": float}
-
-
-def to_absolute(
-    local_pos: Position,
-    parent_pos: Optional[Position] = None,
-) -> Position:
-    """Convert local position to absolute (figure-level) coordinates.
-
-    Args:
-        local_pos: Position relative to parent's origin
-        parent_pos: Parent's absolute position (None = root level)
-
-    Returns:
-        Absolute position in figure coordinates
-
-    Example:
-        >>> to_absolute({"x_mm": 5, "y_mm": 3}, {"x_mm": 10, "y_mm": 10})
-        {"x_mm": 15.0, "y_mm": 13.0}
-    """
-    local = normalize_position(local_pos)
-
-    if parent_pos is None:
-        return local
-
-    parent = normalize_position(parent_pos)
-    return {
-        "x_mm": parent["x_mm"] + local["x_mm"],
-        "y_mm": parent["y_mm"] + local["y_mm"],
-    }
-
-
-def to_relative(
-    absolute_pos: Position,
-    parent_pos: Position,
-) -> Position:
-    """Convert absolute position to local (parent-relative) coordinates.
-
-    Args:
-        absolute_pos: Absolute position in figure coordinates
-        parent_pos: Parent's absolute position
-
-    Returns:
-        Position relative to parent's origin
-
-    Example:
-        >>> to_relative({"x_mm": 15, "y_mm": 13}, {"x_mm": 10, "y_mm": 10})
-        {"x_mm": 5.0, "y_mm": 3.0}
-    """
-    absolute = normalize_position(absolute_pos)
-    parent = normalize_position(parent_pos)
-    return {
-        "x_mm": absolute["x_mm"] - parent["x_mm"],
-        "y_mm": absolute["y_mm"] - parent["y_mm"],
-    }
-
-
-__all__ = ["to_absolute", "to_relative", "Position"]
-
-# EOF

scitex/fts/_kinds/_plot/_utils/_get_template.py

@@ -1,178 +0,0 @@
-#!/usr/bin/env python3
-# Timestamp: 2025-12-20
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/fsb/_fig/_utils/_get_template.py
-
-"""Figure template getter functions for publications."""
-
-from typing import Any, Dict
-
-from ._const_sizes import (
-    DEFAULT_MARGIN_MM,
-    DEFAULT_SPACING_MM,
-    NATURE_DOUBLE_COLUMN_MM,
-    NATURE_SINGLE_COLUMN_MM,
-    SCIENCE_SINGLE_COLUMN_MM,
-)
-
-
-def get_nature_single_column(
-    height_mm: float = 89, nrows: int = 1, ncols: int = 1
-) -> Dict[str, Any]:
-    """Get Nature single column figure template."""
-    return {
-        "width_mm": NATURE_SINGLE_COLUMN_MM,
-        "height_mm": height_mm,
-        "nrows": nrows,
-        "ncols": ncols,
-        "dpi": 300,
-        "left_mm": DEFAULT_MARGIN_MM,
-        "right_mm": DEFAULT_MARGIN_MM,
-        "top_mm": DEFAULT_MARGIN_MM,
-        "bottom_mm": DEFAULT_MARGIN_MM,
-        "wspace_mm": DEFAULT_SPACING_MM,
-        "hspace_mm": DEFAULT_SPACING_MM,
-        "metadata": {"template": "nature_single_column", "journal": "Nature"},
-    }
-
-
-def get_nature_double_column(
-    height_mm: float = 120, nrows: int = 1, ncols: int = 1
-) -> Dict[str, Any]:
-    """Get Nature double column figure template."""
-    return {
-        "width_mm": NATURE_DOUBLE_COLUMN_MM,
-        "height_mm": height_mm,
-        "nrows": nrows,
-        "ncols": ncols,
-        "dpi": 300,
-        "left_mm": DEFAULT_MARGIN_MM,
-        "right_mm": DEFAULT_MARGIN_MM,
-        "top_mm": DEFAULT_MARGIN_MM,
-        "bottom_mm": DEFAULT_MARGIN_MM,
-        "wspace_mm": DEFAULT_SPACING_MM,
-        "hspace_mm": DEFAULT_SPACING_MM,
-        "metadata": {"template": "nature_double_column", "journal": "Nature"},
-    }
-
-
-def get_science_single_column(
-    height_mm: float = 84, nrows: int = 1, ncols: int = 1
-) -> Dict[str, Any]:
-    """Get Science single column figure template."""
-    return {
-        "width_mm": SCIENCE_SINGLE_COLUMN_MM,
-        "height_mm": height_mm,
-        "nrows": nrows,
-        "ncols": ncols,
-        "dpi": 300,
-        "left_mm": DEFAULT_MARGIN_MM,
-        "right_mm": DEFAULT_MARGIN_MM,
-        "top_mm": DEFAULT_MARGIN_MM,
-        "bottom_mm": DEFAULT_MARGIN_MM,
-        "wspace_mm": DEFAULT_SPACING_MM,
-        "hspace_mm": DEFAULT_SPACING_MM,
-        "metadata": {"template": "science_single_column", "journal": "Science"},
-    }
-
-
-def get_a4_figure(
-    width_mm: float = 180, height_mm: float = 120, nrows: int = 1, ncols: int = 1
-) -> Dict[str, Any]:
-    """Get A4-sized figure template."""
-    return {
-        "width_mm": width_mm,
-        "height_mm": height_mm,
-        "nrows": nrows,
-        "ncols": ncols,
-        "dpi": 300,
-        "left_mm": DEFAULT_MARGIN_MM,
-        "right_mm": DEFAULT_MARGIN_MM,
-        "top_mm": DEFAULT_MARGIN_MM,
-        "bottom_mm": DEFAULT_MARGIN_MM,
-        "wspace_mm": DEFAULT_SPACING_MM,
-        "hspace_mm": DEFAULT_SPACING_MM,
-        "metadata": {"template": "a4_figure"},
-    }
-
-
-def get_square_figure(
-    size_mm: float = 120, nrows: int = 1, ncols: int = 1
-) -> Dict[str, Any]:
-    """Get square figure template."""
-    return {
-        "width_mm": size_mm,
-        "height_mm": size_mm,
-        "nrows": nrows,
-        "ncols": ncols,
-        "dpi": 300,
-        "left_mm": DEFAULT_MARGIN_MM,
-        "right_mm": DEFAULT_MARGIN_MM,
-        "top_mm": DEFAULT_MARGIN_MM,
-        "bottom_mm": DEFAULT_MARGIN_MM,
-        "wspace_mm": DEFAULT_SPACING_MM,
-        "hspace_mm": DEFAULT_SPACING_MM,
-        "metadata": {"template": "square_figure"},
-    }
-
-
-def get_presentation_slide(
-    aspect_ratio: str = "16:9", width_mm: float = 254
-) -> Dict[str, Any]:
-    """Get presentation slide figure template."""
-    if aspect_ratio == "16:9":
-        height_mm = width_mm * 9 / 16
-    elif aspect_ratio == "4:3":
-        height_mm = width_mm * 3 / 4
-    else:
-        raise ValueError(f"Unsupported aspect ratio: {aspect_ratio}")
-
-    return {
-        "width_mm": width_mm,
-        "height_mm": height_mm,
-        "nrows": 1,
-        "ncols": 1,
-        "dpi": 150,
-        "left_mm": DEFAULT_MARGIN_MM,
-        "right_mm": DEFAULT_MARGIN_MM,
-        "top_mm": DEFAULT_MARGIN_MM,
-        "bottom_mm": DEFAULT_MARGIN_MM,
-        "metadata": {"template": "presentation_slide", "aspect_ratio": aspect_ratio},
-    }
-
-
-# Template registry
-TEMPLATES = {
-    "nature_single": get_nature_single_column,
-    "nature_double": get_nature_double_column,
-    "science_single": get_science_single_column,
-    "a4": get_a4_figure,
-    "square": get_square_figure,
-    "presentation": get_presentation_slide,
-}
-
-
-def get_template(name: str, **kwargs) -> Dict[str, Any]:
-    """Get a figure template by name."""
-    if name not in TEMPLATES:
-        raise ValueError(f"Unknown template: {name}. Available: {list(TEMPLATES.keys())}")
-    return TEMPLATES[name](**kwargs)
-
-
-def list_templates() -> list:
-    """List available template names."""
-    return list(TEMPLATES.keys())
-
-
-__all__ = [
-    "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",
-]
-
-# EOF

scitex/fts/_kinds/_plot/_utils/_normalize.py

@@ -1,73 +0,0 @@
-#!/usr/bin/env python3
-# Timestamp: 2025-12-20
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/fsb/_fig/_utils/_normalize.py
-
-"""Normalization utilities for position and size values."""
-
-from typing import Any, Dict, Optional
-
-# Type aliases
-Position = Dict[str, float]  # {"x_mm": float, "y_mm": float}
-Size = Dict[str, float]  # {"width_mm": float, "height_mm": float}
-
-# Default values
-DEFAULT_POSITION: Position = {"x_mm": 0.0, "y_mm": 0.0}
-DEFAULT_SIZE: Size = {"width_mm": 80.0, "height_mm": 60.0}
-
-
-def normalize_position(pos: Optional[Dict[str, Any]]) -> Position:
-    """Normalize position to standard format {"x_mm", "y_mm"}.
-
-    Handles various input formats:
-    - {"x_mm": 10, "y_mm": 20}  -> as-is
-    - {"x": 10, "y": 20}        -> convert keys
-    - None                      -> default (0, 0)
-
-    Args:
-        pos: Position dict or None
-
-    Returns:
-        Normalized position with x_mm and y_mm keys
-    """
-    if pos is None:
-        return DEFAULT_POSITION.copy()
-
-    return {
-        "x_mm": float(pos.get("x_mm", pos.get("x", 0.0))),
-        "y_mm": float(pos.get("y_mm", pos.get("y", 0.0))),
-    }
-
-
-def normalize_size(size: Optional[Dict[str, Any]]) -> Size:
-    """Normalize size to standard format {"width_mm", "height_mm"}.
-
-    Handles various input formats:
-    - {"width_mm": 80, "height_mm": 60}  -> as-is
-    - {"width": 80, "height": 60}        -> convert keys
-    - None                               -> default size
-
-    Args:
-        size: Size dict or None
-
-    Returns:
-        Normalized size with width_mm and height_mm keys
-    """
-    if size is None:
-        return DEFAULT_SIZE.copy()
-
-    return {
-        "width_mm": float(size.get("width_mm", size.get("width", 80.0))),
-        "height_mm": float(size.get("height_mm", size.get("height", 60.0))),
-    }
-
-
-__all__ = [
-    "normalize_position",
-    "normalize_size",
-    "Position",
-    "Size",
-    "DEFAULT_POSITION",
-    "DEFAULT_SIZE",
-]
-
-# EOF

scitex/fts/_kinds/_plot/_utils/_validate.py

@@ -1,197 +0,0 @@
-#!/usr/bin/env python3
-# File: ./src/scitex/vis/utils/validate.py
-"""Validation utilities for figure JSON specifications."""
-
-from typing import Any, Dict
-
-
-def validate_json_structure(fig_json: Dict[str, Any]) -> bool:
-    """
-    Validate basic JSON structure requirements.
-
-    Parameters
-    ----------
-    fig_json : Dict[str, Any]
-        Figure JSON to validate
-
-    Returns
-    -------
-    bool
-        True if valid, raises ValueError otherwise
-
-    Raises
-    ------
-    ValueError
-        If JSON structure is invalid
-    """
-    # Required fields
-    required_fields = ["width_mm", "height_mm"]
-
-    for field in required_fields:
-        if field not in fig_json:
-            raise ValueError(f"Missing required field: {field}")
-
-    # Type validation
-    if not isinstance(fig_json["width_mm"], (int, float)):
-        raise ValueError("width_mm must be a number")
-
-    if not isinstance(fig_json["height_mm"], (int, float)):
-        raise ValueError("height_mm must be a number")
-
-    # Value validation
-    if fig_json["width_mm"] <= 0:
-        raise ValueError(f"width_mm must be positive, got {fig_json['width_mm']}")
-
-    if fig_json["height_mm"] <= 0:
-        raise ValueError(f"height_mm must be positive, got {fig_json['height_mm']}")
-
-    # Optional fields validation
-    if "nrows" in fig_json:
-        if not isinstance(fig_json["nrows"], int) or fig_json["nrows"] <= 0:
-            raise ValueError("nrows must be a positive integer")
-
-    if "ncols" in fig_json:
-        if not isinstance(fig_json["ncols"], int) or fig_json["ncols"] <= 0:
-            raise ValueError("ncols must be a positive integer")
-
-    if "dpi" in fig_json:
-        if not isinstance(fig_json["dpi"], int) or fig_json["dpi"] <= 0:
-            raise ValueError("dpi must be a positive integer")
-
-    if "axes" in fig_json:
-        if not isinstance(fig_json["axes"], list):
-            raise ValueError("axes must be a list")
-
-    return True
-
-
-def validate_plot_data(plot_data: Dict[str, Any]) -> bool:
-    """
-    Validate plot data contains required fields for plot type.
-
-    Parameters
-    ----------
-    plot_data : Dict[str, Any]
-        Plot configuration with data
-
-    Returns
-    -------
-    bool
-        True if valid, raises ValueError otherwise
-
-    Raises
-    ------
-    ValueError
-        If plot data is invalid
-    """
-    if "plot_type" not in plot_data:
-        raise ValueError("Plot must specify plot_type")
-
-    plot_type = plot_data["plot_type"]
-    data = plot_data.get("data", {})
-
-    # Type-specific requirements
-    if plot_type in ["line", "scatter", "errorbar"]:
-        if "x" not in data or "y" not in data:
-            raise ValueError(f"{plot_type} requires 'x' and 'y' data")
-
-        # Validate arrays have same length
-        x_len = len(data["x"]) if hasattr(data["x"], "__len__") else 1
-        y_len = len(data["y"]) if hasattr(data["y"], "__len__") else 1
-
-        if x_len != y_len:
-            raise ValueError(f"x and y data must have same length: {x_len} != {y_len}")
-
-    elif plot_type in ["bar", "barh"]:
-        if "x" not in data:
-            raise ValueError(f"{plot_type} requires 'x' data")
-
-        if "height" not in data and "y" not in data:
-            raise ValueError(f"{plot_type} requires 'height' or 'y' data")
-
-    elif plot_type == "hist":
-        if "x" not in data:
-            raise ValueError("hist requires 'x' data")
-
-    elif plot_type in ["heatmap", "imshow"]:
-        if "z" not in data and "img" not in data:
-            raise ValueError(f"{plot_type} requires 'z' or 'img' data")
-
-    elif plot_type in ["contour", "contourf"]:
-        if "x" not in data or "y" not in data or "z" not in data:
-            raise ValueError(f"{plot_type} requires 'x', 'y', and 'z' data")
-
-    return True
-
-
-def check_schema_version(fig_json: Dict[str, Any]) -> str:
-    """
-    Check and return schema version.
-
-    Parameters
-    ----------
-    fig_json : Dict[str, Any]
-        Figure JSON
-
-    Returns
-    -------
-    str
-        Schema version (defaults to "1.0.0" if not specified)
-    """
-    return fig_json.get("schema_version", "1.0.0")
-
-
-def validate_color(color: str) -> bool:
-    """
-    Validate color specification.
-
-    Parameters
-    ----------
-    color : str
-        Color specification (name, hex, rgb, etc.)
-
-    Returns
-    -------
-    bool
-        True if valid, raises ValueError otherwise
-    """
-    if not isinstance(color, str):
-        raise ValueError(f"Color must be a string, got {type(color)}")
-
-    # Basic validation - matplotlib will do deeper validation
-    if not color:
-        raise ValueError("Color cannot be empty string")
-
-    return True
-
-
-def validate_axes_layout(nrows: int, ncols: int, num_axes: int) -> bool:
-    """
-    Validate axes layout is consistent.
-
-    Parameters
-    ----------
-    nrows : int
-        Number of rows
-    ncols : int
-        Number of columns
-    num_axes : int
-        Number of axes configurations
-
-    Returns
-    -------
-    bool
-        True if valid, raises ValueError otherwise
-    """
-    max_axes = nrows * ncols
-
-    if num_axes > max_axes:
-        raise ValueError(
-            f"Too many axes: {num_axes} axes for {nrows}x{ncols} layout "
-            f"(max {max_axes})"
-        )
-
-    return True
-
-
-# EOF