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

scitex/fts/_fig/_editor/_gui/_flask_editor.py

@@ -1,36 +0,0 @@
-#!/usr/bin/env python3
-# File: ./src/scitex/vis/editor/_flask_editor.py
-"""Web-based figure editor using Flask.
-
-This module re-exports from the flask_editor package for backward compatibility.
-The actual implementation is in the flask_editor/ subpackage.
-"""
-
-from ._flask_editor import (
-    WebEditor,
-    check_port_available,
-    find_available_port,
-    kill_process_on_port,
-    plot_from_csv,
-    render_preview_with_bboxes,
-)
-
-# Legacy aliases for backward compatibility
-_find_available_port = find_available_port
-_kill_process_on_port = kill_process_on_port
-
-
-__all__ = [
-    "WebEditor",
-    "find_available_port",
-    "kill_process_on_port",
-    "check_port_available",
-    "render_preview_with_bboxes",
-    "plot_from_csv",
-    # Legacy aliases
-    "_find_available_port",
-    "_kill_process_on_port",
-]
-
-
-# EOF

scitex/fts/_fig/_models/_Annotations.py

@@ -1,115 +0,0 @@
-#!/usr/bin/env python3
-# File: ./src/scitex/vis/model/annotations.py
-"""Annotation JSON model for scitex.fig."""
-
-from dataclasses import asdict, dataclass, field
-from typing import Any, Dict, Optional, Tuple
-
-from ._Styles import TextStyle
-
-
-@dataclass
-class AnnotationModel:
-    """
-    Annotation model for text, arrows, and shapes on plots.
-
-    Separates structure from style properties for easier:
-    - UI property panel generation
-    - Style copy/paste
-    - Batch style application
-
-    Supports:
-    - text: Simple text annotations
-    - annotate: Text with optional arrows
-    - arrow: Arrows without text
-    """
-
-    # Annotation type
-    annotation_type: str  # "text", "annotate", "arrow"
-
-    # Text content
-    text: Optional[str] = None
-
-    # Position (data coordinates)
-    x: float = 0.0
-    y: float = 0.0
-
-    # For annotate: arrow properties
-    xytext: Optional[Tuple[float, float]] = None  # Text position
-
-    # Annotation ID for reference
-    annotation_id: Optional[str] = None
-
-    # Style properties (separated for clean UI/copy/paste)
-    style: TextStyle = field(default_factory=TextStyle)
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary for JSON serialization."""
-        d = asdict(self)
-        # Convert tuples to lists for JSON compatibility
-        if d.get("xytext") is not None:
-            d["xytext"] = list(d["xytext"])
-        d["style"] = self.style.to_dict()
-        return d
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "AnnotationModel":
-        """Create AnnotationModel from dictionary."""
-        # Convert lists back to tuples
-        if "xytext" in data and data["xytext"] is not None:
-            data["xytext"] = tuple(data["xytext"])
-
-        # Handle old format (backward compatibility)
-        if "style" not in data:
-            # Extract style properties from flat structure
-            style_fields = TextStyle.__annotations__.keys()
-            style_data = {k: v for k, v in data.items() if k in style_fields}
-            data = {k: v for k, v in data.items() if k not in style_fields}
-            data["style"] = style_data
-
-        # Extract and parse style
-        style_data = data.pop("style", {})
-        obj = cls(**{k: v for k, v in data.items() if k in cls.__annotations__})
-        obj.style = TextStyle.from_dict(style_data)
-        return obj
-
-    def validate(self) -> bool:
-        """
-        Validate the annotation model.
-
-        Returns
-        -------
-        bool
-            True if valid, raises ValueError otherwise
-        """
-        valid_annotation_types = ["text", "annotate", "arrow"]
-
-        if self.annotation_type not in valid_annotation_types:
-            raise ValueError(
-                f"Invalid annotation_type: {self.annotation_type}. "
-                f"Must be one of {valid_annotation_types}"
-            )
-
-        # Type-specific validation
-        if self.annotation_type in ["text", "annotate"]:
-            if not self.text:
-                raise ValueError(f"{self.annotation_type} requires 'text' parameter")
-
-        if self.annotation_type == "annotate":
-            if self.xytext is None:
-                raise ValueError("annotate requires 'xytext' parameter")
-
-        # Validate alignment (now in style)
-        valid_ha = ["left", "center", "right"]
-        valid_va = ["top", "center", "bottom", "baseline"]
-
-        if self.style.ha not in valid_ha:
-            raise ValueError(f"Invalid ha: {self.style.ha}. Must be one of {valid_ha}")
-
-        if self.style.va not in valid_va:
-            raise ValueError(f"Invalid va: {self.style.va}. Must be one of {valid_va}")
-
-        return True
-
-
-# EOF

scitex/fts/_fig/_models/_Axes.py

@@ -1,152 +0,0 @@
-#!/usr/bin/env python3
-# File: ./src/scitex/vis/model/axes.py
-"""Axes JSON model for scitex.fig."""
-
-from dataclasses import asdict, dataclass, field
-from typing import Any, Dict, List, Optional
-
-from ._Styles import AxesStyle
-
-
-@dataclass
-class AxesModel:
-    """
-    Axes model representing a single subplot.
-
-    Separates structure/data from style properties for easier:
-    - UI property panel generation
-    - Style copy/paste
-    - Batch style application
-
-    Contains all configuration for one subplot including:
-    - Plot data and type
-    - Axis labels, limits, scales
-    - Legends, titles
-    - Annotations and guides
-    """
-
-    # Position in layout (0-based)
-    row: int = 0
-    col: int = 0
-
-    # Plot configurations (list of PlotModel)
-    plots: List[Dict[str, Any]] = field(default_factory=list)
-
-    # Axis labels and titles (content, not style)
-    xlabel: Optional[str] = None
-    ylabel: Optional[str] = None
-    title: Optional[str] = None
-
-    # Axis limits
-    xlim: Optional[List[float]] = None
-    ylim: Optional[List[float]] = None
-
-    # Axis scales
-    xscale: str = "linear"  # "linear", "log", "symlog", "logit"
-    yscale: str = "linear"
-
-    # Ticks
-    xticks: Optional[List[float]] = None
-    yticks: Optional[List[float]] = None
-    xticklabels: Optional[List[str]] = None
-    yticklabels: Optional[List[str]] = None
-
-    # Annotations (list of AnnotationModel)
-    annotations: List[Dict[str, Any]] = field(default_factory=list)
-
-    # Guides (lines, spans, etc.)
-    guides: List[Dict[str, Any]] = field(default_factory=list)
-
-    # Axes ID for reference
-    axes_id: Optional[str] = None
-
-    # Style properties (separated for clean UI/copy/paste)
-    style: AxesStyle = field(default_factory=AxesStyle)
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary for JSON serialization."""
-        d = asdict(self)
-        d["style"] = self.style.to_dict()
-        return d
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "AxesModel":
-        """Create AxesModel from dictionary."""
-        # Handle old format (backward compatibility)
-        if "style" not in data:
-            # Extract style properties from flat structure
-            style_fields = AxesStyle.__annotations__.keys()
-            style_data = {k: v for k, v in data.items() if k in style_fields}
-            data = {k: v for k, v in data.items() if k not in style_fields}
-            data["style"] = style_data
-
-        # Extract and parse style
-        style_data = data.pop("style", {})
-        obj = cls(**{k: v for k, v in data.items() if k in cls.__annotations__})
-        obj.style = AxesStyle.from_dict(style_data)
-        return obj
-
-    def add_plot(self, plot_config: Dict[str, Any]) -> None:
-        """
-        Add a plot configuration to this axes.
-
-        Parameters
-        ----------
-        plot_config : Dict[str, Any]
-            Plot configuration dictionary
-        """
-        self.plots.append(plot_config)
-
-    def add_annotation(self, annotation_config: Dict[str, Any]) -> None:
-        """
-        Add an annotation to this axes.
-
-        Parameters
-        ----------
-        annotation_config : Dict[str, Any]
-            Annotation configuration dictionary
-        """
-        self.annotations.append(annotation_config)
-
-    def add_guide(self, guide_config: Dict[str, Any]) -> None:
-        """
-        Add a guide (line, span, etc.) to this axes.
-
-        Parameters
-        ----------
-        guide_config : Dict[str, Any]
-            Guide configuration dictionary
-        """
-        self.guides.append(guide_config)
-
-    def validate(self) -> bool:
-        """
-        Validate the axes model.
-
-        Returns
-        -------
-        bool
-            True if valid, raises ValueError otherwise
-        """
-        if self.row < 0:
-            raise ValueError(f"row must be non-negative, got {self.row}")
-
-        if self.col < 0:
-            raise ValueError(f"col must be non-negative, got {self.col}")
-
-        if self.xscale not in ["linear", "log", "symlog", "logit"]:
-            raise ValueError(f"Invalid xscale: {self.xscale}")
-
-        if self.yscale not in ["linear", "log", "symlog", "logit"]:
-            raise ValueError(f"Invalid yscale: {self.yscale}")
-
-        if self.xlim is not None and len(self.xlim) != 2:
-            raise ValueError(f"xlim must have 2 elements, got {len(self.xlim)}")
-
-        if self.ylim is not None and len(self.ylim) != 2:
-            raise ValueError(f"ylim must have 2 elements, got {len(self.ylim)}")
-
-        return True
-
-
-# EOF

scitex/fts/_fig/_models/_Figure.py

@@ -1,138 +0,0 @@
-#!/usr/bin/env python3
-# File: ./src/scitex/vis/model/figure.py
-"""Figure JSON model for scitex.fig."""
-
-from dataclasses import asdict, dataclass, field
-from typing import Any, Dict, List, Optional
-
-
-@dataclass
-class FigureModel:
-    """
-    Top-level figure model representing a complete publication figure.
-
-    This model captures all information needed to recreate a figure:
-    - Physical dimensions (mm units)
-    - Subplot layout
-    - Individual axes configurations
-    - Global figure properties
-
-    All measurements use mm units for publication compatibility.
-    """
-
-    # Physical dimensions (mm)
-    width_mm: float
-    height_mm: float
-
-    # Subplot layout
-    nrows: int = 1
-    ncols: int = 1
-
-    # Axes configurations (list of AxesModel)
-    axes: List[Dict[str, Any]] = field(default_factory=list)
-
-    # Figure-level properties
-    dpi: int = 300
-    facecolor: str = "white"
-    edgecolor: str = "none"
-
-    # Spacing (mm)
-    left_mm: Optional[float] = None
-    right_mm: Optional[float] = None
-    top_mm: Optional[float] = None
-    bottom_mm: Optional[float] = None
-    wspace_mm: Optional[float] = None
-    hspace_mm: Optional[float] = None
-
-    # Suptitle
-    suptitle: Optional[str] = None
-    suptitle_fontsize: Optional[float] = None
-    suptitle_fontweight: Optional[str] = None
-    suptitle_y: Optional[float] = None
-
-    # Metadata
-    metadata: Dict[str, Any] = field(default_factory=dict)
-
-    # Figure ID for tracking
-    figure_id: Optional[str] = None
-
-    # Version for schema evolution
-    schema_version: str = "1.0.0"
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary for JSON serialization."""
-        return asdict(self)
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "FigureModel":
-        """Create FigureModel from dictionary."""
-        return cls(**data)
-
-    def validate(self) -> bool:
-        """
-        Validate the figure model.
-
-        Returns
-        -------
-        bool
-            True if valid, raises ValueError otherwise
-        """
-        if self.width_mm <= 0:
-            raise ValueError(f"width_mm must be positive, got {self.width_mm}")
-
-        if self.height_mm <= 0:
-            raise ValueError(f"height_mm must be positive, got {self.height_mm}")
-
-        if self.nrows <= 0:
-            raise ValueError(f"nrows must be positive, got {self.nrows}")
-
-        if self.ncols <= 0:
-            raise ValueError(f"ncols must be positive, got {self.ncols}")
-
-        if self.dpi <= 0:
-            raise ValueError(f"dpi must be positive, got {self.dpi}")
-
-        # Validate that axes count matches layout
-        expected_axes = self.nrows * self.ncols
-        if len(self.axes) > expected_axes:
-            raise ValueError(
-                f"Too many axes: expected {expected_axes} for {self.nrows}x{self.ncols} layout, "
-                f"got {len(self.axes)}"
-            )
-
-        return True
-
-    def get_axes_by_position(self, row: int, col: int) -> Optional[Dict[str, Any]]:
-        """
-        Get axes configuration by subplot position.
-
-        Parameters
-        ----------
-        row : int
-            Row index (0-based)
-        col : int
-            Column index (0-based)
-
-        Returns
-        -------
-        Optional[Dict[str, Any]]
-            Axes configuration or None if not found
-        """
-        idx = row * self.ncols + col
-        if idx < len(self.axes):
-            return self.axes[idx]
-        return None
-
-    def add_axes(self, axes_config: Dict[str, Any]) -> None:
-        """
-        Add an axes configuration to the figure.
-
-        Parameters
-        ----------
-        axes_config : Dict[str, Any]
-            Axes configuration dictionary
-        """
-        self.axes.append(axes_config)
-
-
-# EOF

scitex/fts/_fig/_models/_Plot.py

@@ -1,123 +0,0 @@
-#!/usr/bin/env python3
-# File: ./src/scitex/vis/model/plot.py
-"""Plot JSON model for scitex.fig."""
-
-from dataclasses import asdict, dataclass, field
-from typing import Any, Dict, List, Optional
-
-from ._Styles import PlotStyle
-
-
-@dataclass
-class PlotModel:
-    """
-    Plot model representing a single data visualization within an axes.
-
-    Separates data/structure from style properties for easier:
-    - UI property panel generation
-    - Style copy/paste
-    - Batch style application
-
-    Supports common plot types:
-    - line, scatter, bar, barh, hist
-    - errorbar, fill_between
-    - heatmap, imshow, contour, contourf
-    - box, violin
-    """
-
-    # Plot type
-    plot_type: str  # "line", "scatter", "bar", "errorbar", "heatmap", etc.
-
-    # Data (can be embedded or referenced)
-    data: Dict[str, Any] = field(default_factory=dict)
-
-    # Human-readable identifiers
-    plot_id: Optional[str] = None
-    label: Optional[str] = None
-    tags: List[str] = field(default_factory=list)
-
-    # Style properties (separated for clean UI/copy/paste)
-    style: PlotStyle = field(default_factory=PlotStyle)
-
-    # Additional kwargs for matplotlib (for advanced use)
-    extra_kwargs: Dict[str, Any] = field(default_factory=dict)
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary for JSON serialization."""
-        d = asdict(self)
-        d["style"] = self.style.to_dict()
-        return d
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "PlotModel":
-        """Create PlotModel from dictionary."""
-        # Handle old format (backward compatibility)
-        if "style" not in data:
-            # Extract style properties from flat structure
-            style_fields = PlotStyle.__annotations__.keys()
-            style_data = {k: v for k, v in data.items() if k in style_fields}
-            data = {k: v for k, v in data.items() if k not in style_fields}
-            data["style"] = style_data
-
-        # Extract and parse style
-        style_data = data.pop("style", {})
-        obj = cls(**{k: v for k, v in data.items() if k in cls.__annotations__})
-        obj.style = PlotStyle.from_dict(style_data)
-        return obj
-
-    def validate(self) -> bool:
-        """
-        Validate the plot model.
-
-        Returns
-        -------
-        bool
-            True if valid, raises ValueError otherwise
-        """
-        # Currently implemented plot types
-        # TODO: Add box, violin, step, stem when renderers are implemented
-        valid_plot_types = [
-            "line",
-            "scatter",
-            "bar",
-            "barh",
-            "hist",
-            "errorbar",
-            "fill_between",
-            "heatmap",
-            "imshow",
-            "contour",
-            "contourf",
-        ]
-
-        if self.plot_type not in valid_plot_types:
-            raise ValueError(
-                f"Invalid plot_type: {self.plot_type}. "
-                f"Must be one of {valid_plot_types}"
-            )
-
-        # Validate data exists
-        if not self.data:
-            raise ValueError("Plot must have data")
-
-        # Type-specific validation
-        if self.plot_type in ["heatmap", "imshow"]:
-            if "z" not in self.data and "img" not in self.data:
-                raise ValueError(f"{self.plot_type} requires 'z' or 'img' in data")
-
-        elif self.plot_type in ["line", "scatter", "errorbar"]:
-            if "x" not in self.data or "y" not in self.data:
-                raise ValueError(f"{self.plot_type} requires 'x' and 'y' in data")
-
-        elif self.plot_type in ["bar", "barh"]:
-            if "x" not in self.data or "height" not in self.data:
-                # Allow alternative format with y instead of height
-                if "y" not in self.data:
-                    raise ValueError(
-                        f"{self.plot_type} requires 'x' and 'height' (or 'y') in data"
-                    )
-
-        return True
-
-
-# EOF