figrecipe 0.6.0__py3-none-any.whl → 0.7.4__py3-none-any.whl

figrecipe/_editor/_templates/_styles/_preview.py

@@ -0,0 +1,225 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Preview panel CSS styles for the figure editor.
+
+This module contains CSS for:
+- Preview panel and header
+- SciTeX branding
+- File switcher
+- Zoom controls
+- Preview wrapper and checkerboard background
+"""
+
+STYLES_PREVIEW = """
+/* Preview Panel */
+.preview-panel {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    border-right: 1px solid var(--border-color);
+    min-width: 400px;
+}
+
+.preview-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 12px 16px;
+    background: var(--bg-secondary);
+    border-bottom: 1px solid var(--border-color);
+}
+
+.preview-header h2 {
+    font-size: 16px;
+    font-weight: 600;
+}
+
+/* SciTeX branding */
+.scitex-branding {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    text-decoration: none;
+    color: var(--text-primary);
+    transition: opacity 0.2s;
+}
+
+.scitex-branding:hover {
+    opacity: 0.8;
+}
+
+.scitex-icon {
+    width: 28px;
+    height: 28px;
+    border-radius: 4px;
+}
+
+.figrecipe-title {
+    font-size: 16px;
+    font-weight: 600;
+}
+
+/* File Switcher */
+.file-switcher {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    margin-left: 16px;
+}
+
+.file-selector {
+    padding: 6px 10px;
+    font-size: 13px;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    background: var(--bg-primary);
+    color: var(--text-primary);
+    min-width: 180px;
+    max-width: 280px;
+    cursor: pointer;
+}
+
+.file-selector:hover {
+    border-color: var(--accent-color);
+}
+
+.file-selector:focus {
+    outline: none;
+    border-color: var(--accent-color);
+    box-shadow: 0 0 0 2px var(--selection-color);
+}
+
+.file-selector option {
+    padding: 4px 8px;
+}
+
+.file-selector option[data-current="true"] {
+    font-weight: bold;
+}
+
+.btn-new {
+    width: 28px;
+    height: 28px;
+    padding: 0;
+    font-size: 18px;
+    font-weight: bold;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    background: var(--bg-primary);
+    color: var(--text-primary);
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    transition: all 0.2s;
+}
+
+.btn-new:hover {
+    background: var(--accent-color);
+    color: white;
+    border-color: var(--accent-color);
+}
+
+.preview-controls {
+    display: flex;
+    gap: 12px;
+    align-items: center;
+    flex-wrap: wrap;
+}
+
+.zoom-controls {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+    background: var(--bg-secondary);
+    border-radius: 4px;
+    padding: 2px 6px;
+}
+
+.zoom-controls button {
+    width: 28px;
+    height: 28px;
+    padding: 0;
+    font-size: 16px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.zoom-controls #zoom-level {
+    min-width: 45px;
+    text-align: center;
+    font-size: 12px;
+    font-weight: 500;
+}
+
+.preview-wrapper {
+    flex: 1;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    padding: 20px;
+    background: var(--bg-tertiary);
+    position: relative;
+    overflow: auto;
+    /* Checkerboard pattern for transparency */
+    background-image:
+        linear-gradient(45deg, #ccc 25%, transparent 25%),
+        linear-gradient(-45deg, #ccc 25%, transparent 25%),
+        linear-gradient(45deg, transparent 75%, #ccc 75%),
+        linear-gradient(-45deg, transparent 75%, #ccc 75%);
+    background-size: 20px 20px;
+    background-position: 0 0, 0 10px, 10px -10px, -10px 0px;
+}
+
+/* Dark checkerboard in dark mode */
+[data-theme="dark"] .preview-wrapper {
+    background-color: #2a2a2a;
+    background-image:
+        linear-gradient(45deg, #333333 25%, transparent 25%),
+        linear-gradient(-45deg, #333333 25%, transparent 25%),
+        linear-gradient(45deg, transparent 75%, #333333 75%),
+        linear-gradient(-45deg, transparent 75%, #333333 75%);
+}
+
+#preview-image {
+    max-width: none;
+    max-height: none;
+    object-fit: contain;
+    cursor: crosshair;
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+    position: relative;
+    z-index: 1;
+    transform-origin: center center;
+    transition: transform 0.1s ease-out;
+}
+
+/* Zoom container for coordinated transform of image and overlays */
+.zoom-container {
+    display: inline-block;
+    position: relative;
+    transform-origin: top left;
+    transition: transform 0.1s ease-out;
+}
+
+/* Show grab cursor hint when zoomed in */
+.preview-wrapper.zoomed-in {
+    cursor: grab;
+    /* Disable centering when zoomed to allow proper scrolling from top-left */
+    align-items: flex-start;
+    justify-content: flex-start;
+}
+
+/* Pan cursor when dragging */
+.preview-wrapper.panning {
+    cursor: grabbing !important;
+}
+
+.preview-wrapper.panning * {
+    cursor: grabbing !important;
+}
+"""
+
+__all__ = ["STYLES_PREVIEW"]
+
+# EOF

figrecipe/_editor/_templates/_styles/_selection.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Selection overlay CSS styles for the figure editor.
+
+This module contains CSS for:
+- Selection overlay container
+- Selection rectangles, polylines, circles
+- Primary selection highlights
+"""
+
+STYLES_SELECTION = """
+/* Selection Overlay */
+.selection-overlay {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    pointer-events: none;
+}
+
+.selection-rect {
+    --element-color: #2563eb;  /* Default fallback to accent color */
+    fill: var(--element-color);
+    fill-opacity: 0.15;
+    stroke: var(--element-color);
+    stroke-opacity: 0.6;
+    stroke-width: 2;
+    stroke-dasharray: 5, 3;
+}
+
+/* Primary selection in a group - solid border */
+.selection-rect.selection-primary {
+    fill-opacity: 0.2;
+    stroke-opacity: 0.8;
+    stroke-width: 3;
+    stroke-dasharray: none;
+}
+
+/* Selection for lines - show stroke along the path */
+.selection-polyline {
+    --element-color: #2563eb;
+    fill: none !important;
+    stroke: var(--element-color);
+    stroke-width: 8;
+    stroke-opacity: 0.5;
+    stroke-linecap: round;
+    stroke-linejoin: round;
+}
+
+/* Selection for scatter points */
+.selection-circle {
+    --element-color: #2563eb;
+    fill: var(--element-color);
+    fill-opacity: 0.3;
+    stroke: var(--element-color);
+    stroke-opacity: 0.7;
+    stroke-width: 2;
+}
+
+/* Subtle selection for scatter points (less visually overwhelming) */
+.selection-circle-subtle {
+    --element-color: #2563eb;
+    fill: none;
+    stroke: var(--element-color);
+    stroke-opacity: 0.4;
+    stroke-width: 1.5;
+}
+"""
+
+__all__ = ["STYLES_SELECTION"]
+
+# EOF

figrecipe/_params/_DECORATION_METHODS.py

@@ -22,6 +22,12 @@ DECORATION_METHODS = {
     "text",
     "annotate",
     "clabel",
+    "axis",  # For axis('off'), axis('on'), axis('equal'), etc.
+    "set_xticks",
+    "set_yticks",
+    "set_xticklabels",
+    "set_yticklabels",
+    "tick_params",
 }
 
 # EOF

figrecipe/_recorder.py

@@ -58,6 +58,8 @@ class AxesRecord:
     position: Tuple[int, int]
     calls: List[CallRecord] = field(default_factory=list)
     decorations: List[CallRecord] = field(default_factory=list)
+    # Panel-level caption (e.g., "(A) Description of this panel")
+    caption: Optional[str] = None
 
     def add_call(self, record: CallRecord) -> None:
         """Add a plotting call record."""
@@ -69,10 +71,13 @@ class AxesRecord:
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary for serialization."""
-        return {
+        result = {
             "calls": [c.to_dict() for c in self.calls],
             "decorations": [d.to_dict() for d in self.decorations],
         }
+        if self.caption is not None:
+            result["caption"] = self.caption
+        return result
 
 
 @dataclass
@@ -95,6 +100,11 @@ class FigureRecord:
     suptitle: Optional[Dict[str, Any]] = None
     supxlabel: Optional[Dict[str, Any]] = None
     supylabel: Optional[Dict[str, Any]] = None
+    # Panel labels (A, B, C, D for multi-panel figures)
+    panel_labels: Optional[Dict[str, Any]] = None
+    # Metadata for scientific figures (not rendered, stored in recipe)
+    title_metadata: Optional[str] = None  # Figure title for publication/reference
+    caption: Optional[str] = None  # Figure caption (e.g., "Fig. 1. Description...")
 
     def get_axes_key(self, row: int, col: int) -> str:
         """Get dictionary key for axes at position."""
@@ -138,12 +148,24 @@ class FigureRecord:
         # Add supylabel if set
         if self.supylabel is not None:
             result["figure"]["supylabel"] = self.supylabel
+        # Add panel_labels if set
+        if self.panel_labels is not None:
+            result["figure"]["panel_labels"] = self.panel_labels
+        # Add metadata section for scientific figures
+        metadata = {}
+        if self.title_metadata is not None:
+            metadata["title"] = self.title_metadata
+        if self.caption is not None:
+            metadata["caption"] = self.caption
+        if metadata:
+            result["metadata"] = metadata
         return result
 
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "FigureRecord":
         """Create from dictionary."""
         fig_data = data.get("figure", {})
+        metadata = data.get("metadata", {})
         record = cls(
             id=data.get("id", f"fig_{uuid.uuid4().hex[:8]}"),
             created=data.get("created", ""),
@@ -156,6 +178,9 @@ class FigureRecord:
             suptitle=fig_data.get("suptitle"),
             supxlabel=fig_data.get("supxlabel"),
             supylabel=fig_data.get("supylabel"),
+            panel_labels=fig_data.get("panel_labels"),
+            title_metadata=metadata.get("title"),
+            caption=metadata.get("caption"),
         )
 
         # Reconstruct axes
@@ -167,7 +192,10 @@ class FigureRecord:
             else:
                 row, col = 0, 0
 
-            ax_record = AxesRecord(position=(row, col))
+            ax_record = AxesRecord(
+                position=(row, col),
+                caption=ax_data.get("caption"),
+            )
             for call_data in ax_data.get("calls", []):
                 ax_record.calls.append(CallRecord.from_dict(call_data, (row, col)))
             for dec_data in ax_data.get("decorations", []):
@@ -272,111 +300,12 @@ class Recorder:
         args: tuple,
         method_name: str,
     ) -> List[Dict[str, Any]]:
-        """Process positional arguments for storage.
+        """Process positional arguments for storage."""
+        from ._recorder_utils import process_args
 
-        Parameters
-        ----------
-        args : tuple
-            Raw positional arguments.
-        method_name : str
-            Name of the method.
-
-        Returns
-        -------
-        list
-            Processed args with name and data.
-        """
-        from ._utils._numpy_io import should_store_inline, to_serializable
-
-        processed = []
-        # Simple arg names based on common patterns
-        arg_names = self._get_arg_names(method_name, len(args))
-
-        for i, (name, value) in enumerate(zip(arg_names, args)):
-            # Handle result references (e.g., ContourSet for clabel)
-            if isinstance(value, dict) and "__ref__" in value:
-                processed.append(
-                    {
-                        "name": name,
-                        "data": {"__ref__": value["__ref__"]},
-                    }
-                )
-                continue
-
-            if isinstance(value, np.ndarray):
-                if should_store_inline(value):
-                    processed.append(
-                        {
-                            "name": name,
-                            "data": to_serializable(value),
-                            "dtype": str(value.dtype),
-                        }
-                    )
-                else:
-                    # Mark for file storage (will be handled by serializer)
-                    processed.append(
-                        {
-                            "name": name,
-                            "data": "__FILE__",
-                            "dtype": str(value.dtype),
-                            "_array": value,  # Temporary, removed during serialization
-                        }
-                    )
-            elif hasattr(value, "values"):  # pandas
-                arr = np.asarray(value)
-                if should_store_inline(arr):
-                    processed.append(
-                        {
-                            "name": name,
-                            "data": to_serializable(arr),
-                            "dtype": str(arr.dtype),
-                        }
-                    )
-                else:
-                    processed.append(
-                        {
-                            "name": name,
-                            "data": "__FILE__",
-                            "dtype": str(arr.dtype),
-                            "_array": arr,
-                        }
-                    )
-            elif (
-                isinstance(value, (list, tuple))
-                and len(value) > 0
-                and isinstance(value[0], np.ndarray)
-            ):
-                # List of arrays (e.g., boxplot, violinplot data)
-                arrays_data = [to_serializable(arr) for arr in value]
-                dtypes = [str(arr.dtype) for arr in value]
-                processed.append(
-                    {
-                        "name": name,
-                        "data": arrays_data,
-                        "dtype": (dtypes[0] if len(set(dtypes)) == 1 else dtypes),
-                        "_is_array_list": True,
-                    }
-                )
-            else:
-                # Scalar or other serializable value
-                try:
-                    processed.append(
-                        {
-                            "name": name,
-                            "data": (
-                                value if self._is_serializable(value) else str(value)
-                            ),
-                        }
-                    )
-                except (TypeError, ValueError):
-                    processed.append(
-                        {
-                            "name": name,
-                            "data": str(value),
-                        }
-                    )
-
-        return processed
+        return process_args(
+            args, method_name, self._get_arg_names, self._is_serializable
+        )
 
     def _get_arg_names(self, method_name: str, n_args: int) -> List[str]:
         """Get argument names for a method from signatures.

figrecipe/_recorder_utils.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Utilities for recorder argument processing."""
+
+from typing import Any, Dict, List
+
+import numpy as np
+
+
+def process_args(
+    args: tuple,
+    method_name: str,
+    get_arg_names_func,
+    is_serializable_func,
+) -> List[Dict[str, Any]]:
+    """Process positional arguments for storage.
+
+    Parameters
+    ----------
+    args : tuple
+        Raw positional arguments.
+    method_name : str
+        Name of the method.
+    get_arg_names_func : callable
+        Function to get argument names.
+    is_serializable_func : callable
+        Function to check serializability.
+
+    Returns
+    -------
+    list
+        Processed args with name and data.
+    """
+    from ._utils._numpy_io import should_store_inline, to_serializable
+
+    processed = []
+    arg_names = get_arg_names_func(method_name, len(args))
+
+    for name, value in zip(arg_names, args):
+        processed_arg = _process_single_arg(
+            name, value, should_store_inline, to_serializable, is_serializable_func
+        )
+        processed.append(processed_arg)
+
+    return processed
+
+
+def _process_single_arg(
+    name: str,
+    value: Any,
+    should_store_inline,
+    to_serializable,
+    is_serializable_func,
+) -> Dict[str, Any]:
+    """Process a single argument value."""
+    # Handle result references (e.g., ContourSet for clabel)
+    if isinstance(value, dict) and "__ref__" in value:
+        return {"name": name, "data": {"__ref__": value["__ref__"]}}
+
+    if isinstance(value, np.ndarray):
+        return _process_ndarray(name, value, should_store_inline, to_serializable)
+
+    if hasattr(value, "values"):  # pandas
+        arr = np.asarray(value)
+        return _process_ndarray(name, arr, should_store_inline, to_serializable)
+
+    if (
+        isinstance(value, (list, tuple))
+        and len(value) > 0
+        and isinstance(value[0], np.ndarray)
+    ):
+        # List of arrays (e.g., boxplot, violinplot data)
+        return _process_array_list(name, value, to_serializable)
+
+    # Scalar or other serializable value
+    return _process_scalar(name, value, is_serializable_func)
+
+
+def _process_ndarray(
+    name: str, value: np.ndarray, should_store_inline, to_serializable
+) -> Dict[str, Any]:
+    """Process numpy array argument."""
+    if should_store_inline(value):
+        return {
+            "name": name,
+            "data": to_serializable(value),
+            "dtype": str(value.dtype),
+        }
+    else:
+        # Mark for file storage (will be handled by serializer)
+        return {
+            "name": name,
+            "data": "__FILE__",
+            "dtype": str(value.dtype),
+            "_array": value,  # Temporary, removed during serialization
+        }
+
+
+def _process_array_list(name: str, value: list, to_serializable) -> Dict[str, Any]:
+    """Process list of arrays argument."""
+    arrays_data = [to_serializable(arr) for arr in value]
+    dtypes = [str(arr.dtype) for arr in value]
+    return {
+        "name": name,
+        "data": arrays_data,
+        "dtype": (dtypes[0] if len(set(dtypes)) == 1 else dtypes),
+        "_is_array_list": True,
+    }
+
+
+def _process_scalar(name: str, value: Any, is_serializable_func) -> Dict[str, Any]:
+    """Process scalar or other value."""
+    try:
+        return {
+            "name": name,
+            "data": value if is_serializable_func(value) else str(value),
+        }
+    except (TypeError, ValueError):
+        return {"name": name, "data": str(value)}
+
+
+__all__ = ["process_args"]
+
+# EOF

figrecipe/_reproducer/__init__.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Figure reproduction module.
+
+This module provides functionality to reproduce figures from recipe files.
+The public API exposes three main functions:
+- reproduce: Reproduce a figure from a recipe file
+- reproduce_from_record: Reproduce a figure from a FigureRecord object
+- get_recipe_info: Get information about a recipe without reproducing it
+"""
+
+from ._core import get_recipe_info, reproduce, reproduce_from_record
+
+__all__ = [
+    "reproduce",
+    "reproduce_from_record",
+    "get_recipe_info",
+]