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

scitex/fts/_fig/_backend/__init__.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+# File: ./src/scitex/vis/backend/__init__.py
+"""
+Backend for rendering figure JSON to matplotlib figures.
+
+This module bridges the gap between JSON specifications and
+actual matplotlib figures using scitex.plt.
+"""
+
+from ._export import (
+    export_figure,
+    export_figure_from_file,
+    export_multiple_formats,
+)
+from ._parser import (
+    parse_annotation_json,
+    parse_axes_json,
+    parse_figure_json,
+    parse_guide_json,
+    parse_plot_json,
+    validate_figure_json,
+)
+from ._render import (
+    build_figure_from_json,
+    render_annotation,
+    render_axes,
+    render_figure,
+    render_guide,
+    render_plot,
+)
+
+__all__ = [
+    # Parser
+    "parse_figure_json",
+    "parse_axes_json",
+    "parse_plot_json",
+    "parse_guide_json",
+    "parse_annotation_json",
+    "validate_figure_json",
+    # Renderer
+    "render_figure",
+    "render_axes",
+    "render_plot",
+    "render_guide",
+    "render_annotation",
+    "build_figure_from_json",
+    # Exporter
+    "export_figure",
+    "export_figure_from_file",
+    "export_multiple_formats",
+]
+
+# EOF

scitex/fts/_fig/_backend/_export.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+# File: ./src/scitex/vis/backend/export.py
+"""Export figure models to image files via scitex.io."""
+
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+
+from ._render import build_figure_from_json
+
+
+def export_figure(
+    fig_json: Dict[str, Any],
+    output_path: Union[str, Path],
+    fmt: Optional[str] = None,
+    dpi: int = 300,
+    auto_crop: bool = False,
+    **kwargs,
+) -> Path:
+    """
+    Export figure JSON to image file.
+
+    Parameters
+    ----------
+    fig_json : Dict[str, Any]
+        Figure JSON specification
+    output_path : str or Path
+        Output file path
+    fmt : str, optional
+        Output format ("png", "pdf", "svg", etc.)
+        If None, inferred from output_path extension
+    dpi : int, optional
+        Resolution in dots per inch (default: 300)
+    auto_crop : bool, optional
+        Automatically crop whitespace (default: False)
+    **kwargs
+        Additional keyword arguments passed to scitex.io.save()
+
+    Returns
+    -------
+    Path
+        Path to the saved file
+
+    Examples
+    --------
+    >>> fig_json = {"width_mm": 180, "height_mm": 120, ...}
+    >>> export_figure(fig_json, "output.png", dpi=300)
+    PosixPath('output.png')
+
+    >>> # Auto-crop for publication
+    >>> export_figure(fig_json, "figure.pdf", auto_crop=True)
+    PosixPath('figure.pdf')
+    """
+    import scitex as stx
+
+    output_path = Path(output_path)
+
+    # Build figure from JSON
+    fig, axes = build_figure_from_json(fig_json)
+
+    # Save using scitex.io
+    save_kwargs = {"dpi": dpi, "auto_crop": auto_crop}
+    save_kwargs.update(kwargs)
+
+    if fmt:
+        save_kwargs["fmt"] = fmt
+
+    stx.io.save(fig, output_path, **save_kwargs)
+
+    return output_path
+
+
+def export_figure_from_file(
+    json_path: Union[str, Path],
+    output_path: Union[str, Path],
+    **kwargs,
+) -> Path:
+    """
+    Export figure from JSON file to image file.
+
+    Parameters
+    ----------
+    json_path : str or Path
+        Path to figure JSON file
+    output_path : str or Path
+        Output image file path
+    **kwargs
+        Additional keyword arguments passed to export_figure()
+
+    Returns
+    -------
+    Path
+        Path to the saved file
+
+    Examples
+    --------
+    >>> export_figure_from_file("figure.json", "figure.png")
+    PosixPath('figure.png')
+    """
+    import scitex as stx
+
+    json_path = Path(json_path)
+
+    # Load JSON
+    fig_json = stx.io.load(json_path)
+
+    # Export
+    return export_figure(fig_json, output_path, **kwargs)
+
+
+def export_multiple_formats(
+    fig_json: Dict[str, Any],
+    output_dir: Union[str, Path],
+    base_name: str,
+    formats: list = None,
+    **kwargs,
+) -> Dict[str, Path]:
+    """
+    Export figure to multiple formats.
+
+    Parameters
+    ----------
+    fig_json : Dict[str, Any]
+        Figure JSON specification
+    output_dir : str or Path
+        Output directory
+    base_name : str
+        Base filename (without extension)
+    formats : list, optional
+        List of formats (default: ["png", "pdf", "svg"])
+    **kwargs
+        Additional keyword arguments passed to export_figure()
+
+    Returns
+    -------
+    Dict[str, Path]
+        Dictionary mapping format to output path
+
+    Examples
+    --------
+    >>> fig_json = {...}
+    >>> paths = export_multiple_formats(
+    ...     fig_json,
+    ...     "output",
+    ...     "figure-01",
+    ...     formats=["png", "pdf"]
+    ... )
+    >>> paths
+    {'png': PosixPath('output/figure-01.png'),
+     'pdf': PosixPath('output/figure-01.pdf')}
+    """
+    if formats is None:
+        formats = ["png", "pdf", "svg"]
+
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    results = {}
+    for fmt in formats:
+        output_path = output_dir / f"{base_name}.{fmt}"
+        results[fmt] = export_figure(fig_json, output_path, fmt=fmt, **kwargs)
+
+    return results
+
+
+# EOF

scitex/fts/_fig/_backend/_parser.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+# File: ./src/scitex/vis/backend/parser.py
+"""Parse figure JSON to Python object models."""
+
+from typing import Any, Dict
+
+from .._models import (
+    AnnotationModel,
+    AxesModel,
+    FigureModel,
+    GuideModel,
+    PlotModel,
+)
+
+
+def parse_figure_json(fig_json: Dict[str, Any]) -> FigureModel:
+    """
+    Parse figure JSON into FigureModel.
+
+    Parameters
+    ----------
+    fig_json : Dict[str, Any]
+        Figure JSON specification
+
+    Returns
+    -------
+    FigureModel
+        Parsed figure model
+
+    Examples
+    --------
+    >>> fig_json = {
+    ...     "width_mm": 180,
+    ...     "height_mm": 120,
+    ...     "nrows": 1,
+    ...     "ncols": 2,
+    ...     "axes": [...]
+    ... }
+    >>> fig_model = parse_figure_json(fig_json)
+    """
+    # Parse nested axes
+    axes_data = fig_json.get("axes", [])
+    parsed_axes = [parse_axes_json(ax) for ax in axes_data]
+
+    # Create FigureModel with parsed axes
+    fig_data = fig_json.copy()
+    fig_data["axes"] = [ax.to_dict() for ax in parsed_axes]
+
+    return FigureModel.from_dict(fig_data)
+
+
+def parse_axes_json(axes_json: Dict[str, Any]) -> AxesModel:
+    """
+    Parse axes JSON into AxesModel.
+
+    Parameters
+    ----------
+    axes_json : Dict[str, Any]
+        Axes JSON specification
+
+    Returns
+    -------
+    AxesModel
+        Parsed axes model
+    """
+    # Parse nested plots
+    plots_data = axes_json.get("plots", [])
+    parsed_plots = [parse_plot_json(plot) for plot in plots_data]
+
+    # Parse nested annotations
+    annotations_data = axes_json.get("annotations", [])
+    parsed_annotations = [parse_annotation_json(ann) for ann in annotations_data]
+
+    # Parse nested guides
+    guides_data = axes_json.get("guides", [])
+    parsed_guides = [parse_guide_json(guide) for guide in guides_data]
+
+    # Create AxesModel with parsed children
+    ax_data = axes_json.copy()
+    ax_data["plots"] = [p.to_dict() for p in parsed_plots]
+    ax_data["annotations"] = [a.to_dict() for a in parsed_annotations]
+    ax_data["guides"] = [g.to_dict() for g in parsed_guides]
+
+    return AxesModel.from_dict(ax_data)
+
+
+def parse_plot_json(plot_json: Dict[str, Any]) -> PlotModel:
+    """
+    Parse plot JSON into PlotModel.
+
+    Parameters
+    ----------
+    plot_json : Dict[str, Any]
+        Plot JSON specification
+
+    Returns
+    -------
+    PlotModel
+        Parsed plot model
+    """
+    return PlotModel.from_dict(plot_json)
+
+
+def parse_guide_json(guide_json: Dict[str, Any]) -> GuideModel:
+    """
+    Parse guide JSON into GuideModel.
+
+    Parameters
+    ----------
+    guide_json : Dict[str, Any]
+        Guide JSON specification
+
+    Returns
+    -------
+    GuideModel
+        Parsed guide model
+    """
+    return GuideModel.from_dict(guide_json)
+
+
+def parse_annotation_json(annotation_json: Dict[str, Any]) -> AnnotationModel:
+    """
+    Parse annotation JSON into AnnotationModel.
+
+    Parameters
+    ----------
+    annotation_json : Dict[str, Any]
+        Annotation JSON specification
+
+    Returns
+    -------
+    AnnotationModel
+        Parsed annotation model
+    """
+    return AnnotationModel.from_dict(annotation_json)
+
+
+def validate_figure_json(fig_json: Dict[str, Any]) -> bool:
+    """
+    Validate figure JSON structure (single entry point for validation).
+
+    This is the recommended validation function that performs:
+    1. Basic JSON structure validation (utils.validate_json_structure)
+    2. Model parsing and validation (FigureModel.validate)
+    3. Axes layout validation (utils.validate_axes_layout)
+
+    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
+
+    Examples
+    --------
+    >>> from scitex.fig.backend import validate_figure_json
+    >>> fig_json = {"width_mm": 180, "height_mm": 120, "axes": []}
+    >>> validate_figure_json(fig_json)
+    True
+    """
+    from ..utils import validate_axes_layout, validate_json_structure
+
+    # Step 1: Validate basic JSON structure
+    validate_json_structure(fig_json)
+
+    # Step 2: Parse to models and validate
+    fig_model = parse_figure_json(fig_json)
+    fig_model.validate()
+
+    # Step 3: Validate axes layout consistency
+    validate_axes_layout(
+        nrows=fig_model.nrows,
+        ncols=fig_model.ncols,
+        num_axes=len(fig_model.axes),
+    )
+
+    return True
+
+
+# EOF