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

scitex/fts/_bundle/__init__.py

@@ -1,38 +0,0 @@
-#!/usr/bin/env python3
-# Timestamp: 2025-12-20
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/fts/_bundle/__init__.py
-
-"""FTS Bundle - Core bundle functionality."""
-
-# FTS class
-from ._FTS import FTS, create_bundle, from_matplotlib, load_bundle
-
-# Core dataclasses users need
-from ._dataclasses import BBox, DataInfo, Node, SizeMM
-
-# Type enumeration
-from ._utils import NodeType
-
-# Error classes
-from ._utils import BundleError, BundleNotFoundError, BundleValidationError
-
-__all__ = [
-    # FTS
-    "FTS",
-    "load_bundle",
-    "create_bundle",
-    "from_matplotlib",
-    # Core dataclasses
-    "Node",
-    "BBox",
-    "SizeMM",
-    "DataInfo",
-    # Types
-    "NodeType",
-    # Errors
-    "BundleError",
-    "BundleNotFoundError",
-    "BundleValidationError",
-]
-
-# EOF

scitex/fts/_bundle/_utils/__init__.py

@@ -1,55 +0,0 @@
-#!/usr/bin/env python3
-# Timestamp: 2025-12-20
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/fsb/_bundle/_utils/__init__.py
-
-"""FTS Bundle utilities - types, constants, errors, and helpers."""
-
-# Constants
-from ._const import EXTENSIONS, SCHEMA_NAME, SCHEMA_VERSION, ZIP_EXTENSION
-
-# Types
-from ._types import (
-    TYPE_DEFAULTS,
-    BundleType,
-    NodeType,
-    get_default_constraints,
-)
-
-# Errors
-from ._errors import (
-    BundleError,
-    BundleNotFoundError,
-    BundleValidationError,
-    CircularReferenceError,
-    ConstraintError,
-    DepthLimitError,
-    NestedBundleNotFoundError,
-)
-
-# Generation
-from ._generate import generate_bundle_id
-
-__all__ = [
-    # Constants
-    "ZIP_EXTENSION",
-    "EXTENSIONS",
-    "SCHEMA_NAME",
-    "SCHEMA_VERSION",
-    # Types
-    "NodeType",
-    "BundleType",
-    "TYPE_DEFAULTS",
-    "get_default_constraints",
-    # Errors
-    "BundleError",
-    "BundleValidationError",
-    "BundleNotFoundError",
-    "NestedBundleNotFoundError",
-    "CircularReferenceError",
-    "DepthLimitError",
-    "ConstraintError",
-    # Generation
-    "generate_bundle_id",
-]
-
-# EOF

scitex/fts/_bundle/_utils/_const.py

@@ -1,26 +0,0 @@
-#!/usr/bin/env python3
-# Timestamp: 2025-12-20
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/fsb/_bundle/_utils/_const.py
-
-"""FTS Bundle constants."""
-
-from typing import Tuple
-
-# Bundle extension (ZIP for portability, or directory)
-ZIP_EXTENSION: str = ".zip"
-
-# Supported formats: .zip files or directories (no extension)
-EXTENSIONS: Tuple[str, ...] = (".zip",)
-
-# Schema constants
-SCHEMA_NAME = "scitex.fts"
-SCHEMA_VERSION = "1.0.0"
-
-__all__ = [
-    "ZIP_EXTENSION",
-    "EXTENSIONS",
-    "SCHEMA_NAME",
-    "SCHEMA_VERSION",
-]
-
-# EOF

scitex/fts/_bundle/_utils/_errors.py

@@ -1,73 +0,0 @@
-#!/usr/bin/env python3
-# Timestamp: 2025-12-20
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/fsb/_bundle/_utils/_errors.py
-
-"""FTS Bundle error classes."""
-
-
-class BundleError(Exception):
-    """Base exception for bundle operations."""
-
-    pass
-
-
-class BundleValidationError(BundleError, ValueError):
-    """Error raised when bundle validation fails."""
-
-    pass
-
-
-class BundleNotFoundError(BundleError, FileNotFoundError):
-    """Error raised when a bundle is not found."""
-
-    pass
-
-
-class NestedBundleNotFoundError(BundleNotFoundError):
-    """Error raised when a nested bundle or file within it is not found."""
-
-    pass
-
-
-class CircularReferenceError(BundleValidationError):
-    """Error raised when circular reference is detected in bundle hierarchy.
-
-    This occurs when a bundle references itself directly or indirectly
-    through its children, detected via bundle_id tracking.
-    """
-
-    pass
-
-
-class DepthLimitError(BundleValidationError):
-    """Error raised when bundle nesting exceeds max_depth constraint.
-
-    The max_depth is defined per bundle type in TYPE_DEFAULTS.
-    Default is 3 for figures, 1 for leaf types.
-    """
-
-    pass
-
-
-class ConstraintError(BundleValidationError):
-    """Error raised when bundle violates its type constraints.
-
-    Examples:
-    - Leaf type (plot, stats) has children
-    - Unknown type specified
-    """
-
-    pass
-
-
-__all__ = [
-    "BundleError",
-    "BundleValidationError",
-    "BundleNotFoundError",
-    "NestedBundleNotFoundError",
-    "CircularReferenceError",
-    "DepthLimitError",
-    "ConstraintError",
-]
-
-# EOF

scitex/fts/_bundle/_utils/_generate.py

@@ -1,21 +0,0 @@
-#!/usr/bin/env python3
-# Timestamp: 2025-12-20
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/fsb/_bundle/_utils/_generate.py
-
-"""FTS Bundle ID generation utilities."""
-
-import uuid
-
-
-def generate_bundle_id() -> str:
-    """Generate a unique bundle ID (UUID4).
-
-    Returns:
-        A new UUID4 string.
-    """
-    return str(uuid.uuid4())
-
-
-__all__ = ["generate_bundle_id"]
-
-# EOF

scitex/fts/_bundle/_utils/_types.py

@@ -1,76 +0,0 @@
-#!/usr/bin/env python3
-# Timestamp: 2025-12-20
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/fsb/_bundle/_utils/_types.py
-
-"""FTS Node type constants and constraints."""
-
-from typing import Any, Dict
-
-
-class NodeType:
-    """Node type constants for FTS bundles.
-
-    The type is stored in node.json["type"].
-
-    Usage:
-        from scitex.fts import NodeType
-
-        if bundle.node.type == NodeType.FIGURE:
-            ...
-
-    Note:
-        Tables are treated as structured figures in academic contexts.
-        FTS handles figures, tables, and statistics in a unified way.
-    """
-
-    FIGURE = "figure"
-    PLOT = "plot"
-    TABLE = "table"  # Structured data presentation (demographics, results, etc.)
-    STATS = "stats"
-    IMAGE = "image"
-    TEXT = "text"
-    SHAPE = "shape"
-    SYMBOL = "symbol"
-    COMMENT = "comment"
-    EQUATION = "equation"
-
-
-# Legacy alias (deprecated)
-BundleType = NodeType
-
-
-# Type-specific default constraints
-TYPE_DEFAULTS: Dict[str, Dict[str, Any]] = {
-    "figure": {"allow_children": True, "max_depth": 3},
-    "plot": {"allow_children": False, "max_depth": 1},
-    "table": {"allow_children": False, "max_depth": 1},  # Tables are leaf nodes
-    "stats": {"allow_children": False, "max_depth": 1},
-    "image": {"allow_children": False, "max_depth": 1},
-    "text": {"allow_children": False, "max_depth": 1},
-    "shape": {"allow_children": False, "max_depth": 1},
-    "symbol": {"allow_children": False, "max_depth": 1},
-    "comment": {"allow_children": False, "max_depth": 1},
-    "equation": {"allow_children": False, "max_depth": 1},
-}
-
-
-def get_default_constraints(node_type: str) -> Dict[str, Any]:
-    """Get default constraints for a node type.
-
-    Args:
-        node_type: Type string (figure, plot, stats, etc.)
-
-    Returns:
-        Dict with allow_children and max_depth.
-    """
-    return TYPE_DEFAULTS.get(node_type, {"allow_children": False, "max_depth": 1})
-
-
-__all__ = [
-    "NodeType",
-    "BundleType",
-    "TYPE_DEFAULTS",
-    "get_default_constraints",
-]
-
-# EOF

scitex/fts/_bundle/_zipbundle.py

@@ -1,165 +0,0 @@
-#!/usr/bin/env python3
-# Timestamp: 2025-12-20
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/fsb/_zipbundle.py
-
-"""ZipBundle - Simple ZIP file wrapper for FTS bundles."""
-
-import json
-import zipfile
-from pathlib import Path
-from typing import Any, Dict, Optional, Union
-
-__all__ = ["ZipBundle"]
-
-
-class ZipBundle:
-    """Simple ZIP file wrapper for reading/writing bundle data.
-
-    Provides a context manager interface for working with ZIP files.
-
-    Usage:
-        # Read mode
-        with ZipBundle("bundle.zip", mode="r") as bundle:
-            spec = bundle.read_json("spec.json")
-            data = bundle.read_bytes("data.csv")
-
-        # Write/append mode
-        with ZipBundle("bundle.zip", mode="a") as bundle:
-            bundle.write_json("spec.json", {"type": "plot"})
-            bundle.write_bytes("data.csv", csv_bytes)
-    """
-
-    def __init__(self, path: Union[str, Path], mode: str = "r"):
-        """Initialize ZipBundle.
-
-        Args:
-            path: Path to ZIP file.
-            mode: File mode ('r' for read, 'w' for write, 'a' for append).
-        """
-        self.path = Path(path)
-        self.mode = mode
-        self._zf: Optional[zipfile.ZipFile] = None
-
-    def __enter__(self) -> "ZipBundle":
-        """Enter context manager."""
-        self._zf = zipfile.ZipFile(self.path, self.mode)
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """Exit context manager."""
-        if self._zf:
-            self._zf.close()
-            self._zf = None
-
-    def read_json(self, name: str) -> Dict[str, Any]:
-        """Read JSON file from ZIP.
-
-        Args:
-            name: File name within ZIP.
-
-        Returns:
-            Parsed JSON data.
-        """
-        if not self._zf:
-            raise RuntimeError("ZipBundle not open")
-
-        # Try direct path first
-        try:
-            data = self._zf.read(name)
-            return json.loads(data.decode("utf-8"))
-        except KeyError:
-            pass
-
-        # Try with .d/ directory prefix
-        for item in self._zf.namelist():
-            if item.endswith(f"/{name}") or item == name:
-                data = self._zf.read(item)
-                return json.loads(data.decode("utf-8"))
-
-        raise FileNotFoundError(f"File not found in ZIP: {name}")
-
-    def read_bytes(self, name: str) -> bytes:
-        """Read raw bytes from ZIP.
-
-        Args:
-            name: File name within ZIP.
-
-        Returns:
-            Raw file bytes.
-        """
-        if not self._zf:
-            raise RuntimeError("ZipBundle not open")
-
-        # Try direct path first
-        try:
-            return self._zf.read(name)
-        except KeyError:
-            pass
-
-        # Try with .d/ directory prefix
-        for item in self._zf.namelist():
-            if item.endswith(f"/{name}") or item == name:
-                return self._zf.read(item)
-
-        raise FileNotFoundError(f"File not found in ZIP: {name}")
-
-    def write_json(self, name: str, data: Dict[str, Any], indent: int = 2) -> None:
-        """Write JSON file to ZIP.
-
-        Args:
-            name: File name within ZIP.
-            data: Data to write.
-            indent: JSON indentation level.
-        """
-        if not self._zf:
-            raise RuntimeError("ZipBundle not open")
-
-        json_str = json.dumps(data, indent=indent)
-        self._zf.writestr(name, json_str.encode("utf-8"))
-
-    def write_bytes(self, name: str, data: bytes) -> None:
-        """Write raw bytes to ZIP.
-
-        Args:
-            name: File name within ZIP.
-            data: Data to write.
-        """
-        if not self._zf:
-            raise RuntimeError("ZipBundle not open")
-
-        self._zf.writestr(name, data)
-
-    def namelist(self) -> list:
-        """List files in ZIP.
-
-        Returns:
-            List of file names.
-        """
-        if not self._zf:
-            raise RuntimeError("ZipBundle not open")
-        return self._zf.namelist()
-
-    def exists(self, name: str) -> bool:
-        """Check if file exists in ZIP.
-
-        Args:
-            name: File name to check.
-
-        Returns:
-            True if file exists.
-        """
-        if not self._zf:
-            raise RuntimeError("ZipBundle not open")
-
-        if name in self._zf.namelist():
-            return True
-
-        # Check with .d/ directory prefix
-        for item in self._zf.namelist():
-            if item.endswith(f"/{name}"):
-                return True
-
-        return False
-
-
-# EOF

scitex/fts/_fig/__init__.py

@@ -1,22 +0,0 @@
-#!/usr/bin/env python3
-# Timestamp: 2025-12-20
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/fsb/_fig/__init__.py
-
-"""FTS Figure - Encoding and Theme dataclasses."""
-
-# Public dataclasses
-from ._dataclasses import (
-    ENCODING_VERSION,
-    THEME_VERSION,
-    Encoding,
-    Theme,
-)
-
-__all__ = [
-    "ENCODING_VERSION",
-    "THEME_VERSION",
-    "Encoding",
-    "Theme",
-]
-
-# EOF

scitex/fts/_fig/_backend/_parser.py

@@ -1,188 +0,0 @@
-#!/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

scitex/fts/_fig/_editor/__init__.py

@@ -1,14 +0,0 @@
-#!/usr/bin/env python3
-# Timestamp: 2025-12-20
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/fsb/_fig/editor/__init__.py
-
-"""FTS Figure Editor - Interactive GUI for editing figure styles."""
-
-from ._cui import edit, save_manual_overrides
-
-__all__ = [
-    "edit",
-    "save_manual_overrides",
-]
-
-# EOF