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

figrecipe/_editor/_routes_datatable.py

@@ -0,0 +1,364 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Datatable-related Flask route handlers for the figure editor.
+Handles data extraction from figures and plotting from spreadsheet data.
+"""
+
+from flask import jsonify, request
+
+from ._helpers import render_with_overrides, to_json_serializable
+
+
+def register_datatable_routes(app, editor):
+    """Register datatable-related routes with the Flask app."""
+    from ._hitmap import generate_hitmap, hitmap_to_base64
+
+    @app.route("/datatable/data")
+    def get_datatable_data():
+        """Extract plottable data from the current figure's recorded calls.
+
+        Returns column-oriented data suitable for spreadsheet display.
+        """
+        fig = editor.fig
+        if not hasattr(fig, "_recorder") or fig._recorder is None:
+            return jsonify({"columns": [], "rows": []})
+
+        record = fig._recorder._figure_record
+
+        # Collect all plot data
+        columns = []
+        all_data = {}
+        decoration_funcs = {
+            "set_xlabel",
+            "set_ylabel",
+            "set_title",
+            "set_xlim",
+            "set_ylim",
+            "legend",
+            "grid",
+            "axhline",
+            "axvline",
+            "text",
+            "annotate",
+        }
+
+        for ax_key, ax_record in record.axes.items():
+            for call in ax_record.calls:
+                if call.function in decoration_funcs:
+                    continue
+
+                call_id = call.id or f"{ax_key}_{call.function}_{id(call)}"
+
+                def extract_data(val):
+                    """Extract raw data from value, handling dict wrappers."""
+                    if isinstance(val, dict) and "data" in val:
+                        return val["data"]
+                    if isinstance(val, (list, tuple)):
+                        return list(val)
+                    return None
+
+                # Convert args to serializable format
+                args = to_json_serializable(call.args)
+                kwargs = to_json_serializable(call.kwargs)
+
+                # Extract x, y data from args
+                if args:
+                    if len(args) >= 2:
+                        x_data = extract_data(args[0])
+                        y_data = extract_data(args[1])
+                        if x_data is not None:
+                            col_name = f"{call_id}_x"
+                            all_data[col_name] = x_data
+                            columns.append(
+                                {
+                                    "name": col_name,
+                                    "type": "numeric"
+                                    if all(
+                                        isinstance(v, (int, float))
+                                        for v in x_data
+                                        if v is not None
+                                    )
+                                    else "string",
+                                    "index": len(columns),
+                                }
+                            )
+                        if y_data is not None:
+                            col_name = f"{call_id}_y"
+                            all_data[col_name] = y_data
+                            columns.append(
+                                {
+                                    "name": col_name,
+                                    "type": "numeric"
+                                    if all(
+                                        isinstance(v, (int, float))
+                                        for v in y_data
+                                        if v is not None
+                                    )
+                                    else "string",
+                                    "index": len(columns),
+                                }
+                            )
+                    elif len(args) == 1:
+                        y_data = extract_data(args[0])
+                        if y_data is not None:
+                            col_name = f"{call_id}_y"
+                            all_data[col_name] = y_data
+                            columns.append(
+                                {
+                                    "name": col_name,
+                                    "type": "numeric"
+                                    if all(
+                                        isinstance(v, (int, float))
+                                        for v in y_data
+                                        if v is not None
+                                    )
+                                    else "string",
+                                    "index": len(columns),
+                                }
+                            )
+
+                # Extract from kwargs
+                for key in ["x", "y", "height", "width", "c", "s"]:
+                    if key in kwargs:
+                        val = extract_data(kwargs[key])
+                        if val is not None:
+                            col_name = f"{call_id}_{key}"
+                            if col_name not in all_data:
+                                all_data[col_name] = val
+                                columns.append(
+                                    {
+                                        "name": col_name,
+                                        "type": "numeric"
+                                        if all(
+                                            isinstance(v, (int, float))
+                                            for v in val
+                                            if v is not None
+                                        )
+                                        else "string",
+                                        "index": len(columns),
+                                    }
+                                )
+
+        if not all_data:
+            return jsonify({"columns": [], "rows": []})
+
+        # Convert to row-oriented format
+        max_len = max(len(v) for v in all_data.values()) if all_data else 0
+        rows = []
+        col_names = [c["name"] for c in columns]
+        for i in range(max_len):
+            row = []
+            for name in col_names:
+                data = all_data.get(name, [])
+                if i < len(data):
+                    row.append(data[i])
+                else:
+                    row.append(None)
+            rows.append(row)
+
+        return jsonify({"columns": columns, "rows": rows})
+
+    @app.route("/datatable/plot", methods=["POST"])
+    def plot_from_datatable():
+        """Create a plot from datatable column selections.
+
+        Expected request body:
+        {
+            "data": {"col1": [1,2,3], "col2": [4,5,6]},
+            "columns": ["col1", "col2"],
+            "plot_type": "line",  # or "scatter", "bar", "histogram"
+            "target_axis": null  # null=new figure, 0+=existing axis index
+        }
+        """
+
+        data = request.get_json() or {}
+        plot_data = data.get("data", {})
+        columns = data.get("columns", [])
+        plot_type = data.get("plot_type", "line")
+        target_axis = data.get("target_axis")  # None = new figure
+
+        if not columns:
+            return jsonify({"error": "Please select columns to plot"}), 400
+
+        if not plot_data:
+            return jsonify(
+                {"error": "No data available. Drop CSV/TSV data first."}
+            ), 400
+
+        # Check if all columns have empty data
+        has_data = any(len(plot_data.get(col, [])) > 0 for col in columns)
+        if not has_data:
+            return jsonify({"error": "Selected columns have no data"}), 400
+
+        try:
+            mpl_fig = editor.fig.fig if hasattr(editor.fig, "fig") else editor.fig
+            axes = mpl_fig.get_axes()
+
+            # Determine target axis
+            if target_axis is not None and target_axis < len(axes):
+                # Plot to existing panel
+                ax = axes[target_axis]
+            else:
+                # Add new panel to existing figure
+                n_axes = len(axes)
+                if n_axes == 0:
+                    ax = mpl_fig.add_subplot(111)
+                else:
+                    # Expand figure width to accommodate new panel
+                    current_width, current_height = mpl_fig.get_size_inches()
+                    # Each panel gets ~60mm width, add space for new panel
+                    panel_width_inches = 60 / 25.4  # 60mm in inches
+                    new_width = current_width + panel_width_inches
+                    mpl_fig.set_size_inches(new_width, current_height)
+
+                    # Recalculate positions for all axes
+                    n_cols = n_axes + 1
+                    margin = 0.08
+                    spacing = 0.05
+                    panel_w = (1 - 2 * margin - (n_cols - 1) * spacing) / n_cols
+
+                    for i, old_ax in enumerate(axes):
+                        left = margin + i * (panel_w + spacing)
+                        old_ax.set_position([left, 0.15, panel_w, 0.75])
+
+                    # Add new panel
+                    left = margin + n_axes * (panel_w + spacing)
+                    ax = mpl_fig.add_axes([left, 0.15, panel_w, 0.75])
+
+            # Dispatch plot using helper
+            from ._datatable_plot_handlers import dispatch_plot
+
+            try:
+                dispatch_plot(ax, plot_type, plot_data, columns)
+            except ValueError as e:
+                return jsonify({"error": str(e)}), 400
+
+            # Apply current style and render existing figure
+            effective_style = editor.get_effective_style()
+            recording_fig = editor.fig
+
+            # Update initial axes positions after adding new panel
+            editor._initial_axes_positions = editor._capture_axes_positions()
+
+            # Render
+            base64_img, bboxes, img_size = render_with_overrides(
+                recording_fig,
+                effective_style,
+                editor.dark_mode,
+            )
+
+            # Generate hitmap
+            hitmap_img, color_map = generate_hitmap(recording_fig, dpi=150)
+            editor._color_map = color_map
+            editor._hitmap_base64 = hitmap_to_base64(hitmap_img)
+            editor._hitmap_generated = True
+
+            return jsonify(
+                {
+                    "success": True,
+                    "image": base64_img,
+                    "bboxes": bboxes,
+                    "img_size": {"width": img_size[0], "height": img_size[1]},
+                }
+            )
+
+        except Exception as e:
+            import traceback
+
+            traceback.print_exc()
+            # Provide user-friendly error message
+            error_str = str(e)
+            if "Renderer" in error_str or "backend" in error_str:
+                error_msg = (
+                    "Failed to render plot. Please check your data and try again."
+                )
+            elif "empty" in error_str.lower() or "no data" in error_str.lower():
+                error_msg = "No data to plot. Please select columns with numeric data."
+            else:
+                error_msg = f"Plot error: {type(e).__name__}"
+            return jsonify({"error": error_msg}), 500
+
+    @app.route("/datatable/import", methods=["POST"])
+    def import_datatable():
+        """Import data from uploaded file content.
+
+        Expected request body:
+        {
+            "content": "csv or json content as string",
+            "format": "csv" | "json" | "tsv"
+        }
+        """
+        import csv
+        import io
+        import json
+
+        data = request.get_json() or {}
+        content = data.get("content", "")
+        fmt = data.get("format", "csv").lower()
+
+        try:
+            if fmt == "json":
+                parsed = json.loads(content)
+                if isinstance(parsed, list):
+                    # Array of objects
+                    if not parsed:
+                        return jsonify({"columns": [], "rows": []})
+                    headers = list(parsed[0].keys())
+                    rows = [[obj.get(h) for h in headers] for obj in parsed]
+                elif isinstance(parsed, dict):
+                    # Object with column arrays
+                    headers = list(parsed.keys())
+                    max_len = max(
+                        len(v) if isinstance(v, list) else 1 for v in parsed.values()
+                    )
+                    rows = []
+                    for i in range(max_len):
+                        row = []
+                        for h in headers:
+                            v = parsed[h]
+                            if isinstance(v, list):
+                                row.append(v[i] if i < len(v) else None)
+                            else:
+                                row.append(v if i == 0 else None)
+                        rows.append(row)
+                else:
+                    return jsonify({"error": "Invalid JSON structure"}), 400
+            else:
+                # CSV or TSV
+                delimiter = "\t" if fmt == "tsv" else ","
+                reader = csv.reader(io.StringIO(content), delimiter=delimiter)
+                lines = list(reader)
+                if not lines:
+                    return jsonify({"columns": [], "rows": []})
+                headers = lines[0]
+                rows = []
+                for line in lines[1:]:
+                    row = []
+                    for i, val in enumerate(line):
+                        try:
+                            row.append(float(val))
+                        except ValueError:
+                            row.append(val)
+                    rows.append(row)
+
+            # Determine column types
+            columns = []
+            for i, name in enumerate(headers):
+                values = [row[i] for row in rows if i < len(row) and row[i] is not None]
+                is_numeric = all(isinstance(v, (int, float)) for v in values)
+                columns.append(
+                    {
+                        "name": name,
+                        "type": "numeric" if is_numeric else "string",
+                        "index": i,
+                    }
+                )
+
+            return jsonify({"columns": columns, "rows": rows})
+
+        except Exception as e:
+            return jsonify({"error": str(e)}), 400
+
+
+__all__ = ["register_datatable_routes"]

figrecipe/_editor/_routes_element.py

@@ -0,0 +1,335 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Element-related Flask route handlers for the figure editor.
+Handles calls, download, and shutdown routes.
+"""
+
+from flask import jsonify, request, send_file
+
+from ._helpers import render_with_overrides, to_json_serializable
+
+
+def register_element_routes(app, editor):
+    """Register element-related routes with the Flask app."""
+    from ._hitmap import generate_hitmap, hitmap_to_base64
+    from ._renderer import render_download
+
+    @app.route("/calls")
+    def get_calls():
+        """Get all recorded calls with their signatures."""
+        from .._signatures import get_signature
+
+        calls_data = {}
+        if hasattr(editor.fig, "record"):
+            for ax_key, ax_record in editor.fig.record.axes.items():
+                for call in ax_record.calls:
+                    call_id = call.id
+                    func_name = call.function
+                    sig = get_signature(func_name)
+
+                    calls_data[call_id] = {
+                        "function": func_name,
+                        "ax_key": ax_key,
+                        "args": to_json_serializable(call.args),
+                        "kwargs": to_json_serializable(call.kwargs),
+                        "signature": {
+                            "args": sig.get("args", []),
+                            "kwargs": {
+                                k: v
+                                for k, v in sig.get("kwargs", {}).items()
+                                if k != "**kwargs"
+                            },
+                        },
+                    }
+
+        return jsonify(calls_data)
+
+    @app.route("/call/<call_id>")
+    def get_call(call_id):
+        """Get recorded call data by call_id."""
+        from .._signatures import get_signature
+
+        if hasattr(editor.fig, "record"):
+            for ax_key, ax_record in editor.fig.record.axes.items():
+                for call in ax_record.calls:
+                    if call.id == call_id:
+                        sig = get_signature(call.function)
+                        return jsonify(
+                            {
+                                "call_id": call_id,
+                                "function": call.function,
+                                "ax_key": ax_key,
+                                "args": call.args,
+                                "kwargs": call.kwargs,
+                                "signature": {
+                                    "args": sig.get("args", []),
+                                    "kwargs": {
+                                        k: v
+                                        for k, v in sig.get("kwargs", {}).items()
+                                        if k != "**kwargs"
+                                    },
+                                },
+                            }
+                        )
+
+        return jsonify({"error": f"Call {call_id} not found"}), 404
+
+    @app.route("/update_call", methods=["POST"])
+    def update_call():
+        """Update a call's kwargs and re-render.
+
+        Uses IDENTICAL pipeline as all other routes:
+        1. Store override via set_call_override()
+        2. Call render_with_overrides(editor.fig) - same as initial render
+
+        The actual property application happens in apply_overrides() via
+        apply_call_overrides() - SINGLE SOURCE OF TRUTH.
+        """
+        data = request.get_json() or {}
+        call_id = data.get("call_id")
+        param = data.get("param")
+        value = data.get("value")
+
+        if not call_id or not param:
+            return jsonify({"error": "Missing call_id or param"}), 400
+
+        # Find the call and store override
+        updated = False
+        if hasattr(editor.fig, "record"):
+            for ax_key, ax_record in editor.fig.record.axes.items():
+                for call in ax_record.calls:
+                    if call.id == call_id:
+                        # Store override - will be applied via apply_overrides()
+                        editor.style_overrides.set_call_override(call_id, param, value)
+
+                        # Also update record kwargs for persistence
+                        if value is None or value == "" or value == "null":
+                            call.kwargs.pop(param, None)
+                        else:
+                            call.kwargs[param] = value
+
+                        updated = True
+                        break
+                if updated:
+                    break
+
+        if not updated:
+            return jsonify({"error": f"Call {call_id} not found"}), 404
+
+        # Auto-save recipe if we have a recipe path
+        if editor.recipe_path and hasattr(editor.fig, "save_recipe"):
+            try:
+                editor.fig.save_recipe(editor.recipe_path)
+            except Exception as save_err:
+                print(f"[Auto-save] Warning: Could not save recipe: {save_err}")
+
+        try:
+            # IDENTICAL to all other routes - single source of truth
+            base64_img, bboxes, img_size = render_with_overrides(
+                editor.fig,
+                editor.get_effective_style(),
+                editor.dark_mode,
+            )
+
+            # Regenerate hitmap
+            hitmap_img, color_map = generate_hitmap(editor.fig, dpi=150)
+            editor._color_map = color_map
+            editor._hitmap_base64 = hitmap_to_base64(hitmap_img)
+            editor._hitmap_generated = True
+
+        except Exception as e:
+            import traceback
+
+            traceback.print_exc()
+            return jsonify({"error": f"Re-render failed: {str(e)}"}), 500
+
+        # Get updated call data to sync frontend
+        updated_call_data = None
+        if hasattr(editor.fig, "record"):
+            for ax_key, ax_record in editor.fig.record.axes.items():
+                for call in ax_record.calls:
+                    if call.id == call_id:
+                        updated_call_data = {
+                            "kwargs": to_json_serializable(call.kwargs),
+                        }
+                        break
+                if updated_call_data:
+                    break
+
+        return jsonify(
+            {
+                "success": True,
+                "image": base64_img,
+                "bboxes": bboxes,
+                "img_size": {"width": img_size[0], "height": img_size[1]},
+                "call_id": call_id,
+                "param": param,
+                "value": value,
+                "has_call_overrides": editor.style_overrides.has_call_overrides(),
+                "updated_call": updated_call_data,
+            }
+        )
+
+    @app.route("/download/csv")
+    def download_csv():
+        """Download plotted data as CSV."""
+        import csv
+        import io
+
+        # Get the recorder from the figure
+        fig = editor.fig
+        if not hasattr(fig, "_recorder") or fig._recorder is None:
+            return jsonify({"error": "No recorded data available"}), 400
+
+        record = fig._recorder._figure_record
+
+        # Collect all plot data
+        all_data = {}
+        decoration_funcs = {
+            "set_xlabel",
+            "set_ylabel",
+            "set_title",
+            "set_xlim",
+            "set_ylim",
+            "legend",
+            "grid",
+            "axhline",
+            "axvline",
+            "text",
+            "annotate",
+        }
+
+        for ax_key, ax_record in record.axes.items():
+            for call in ax_record.calls:
+                if call.function in decoration_funcs:
+                    continue
+
+                call_id = call.id or f"{ax_key}_{call.function}_{id(call)}"
+                call_data = {}
+
+                def extract_data(val):
+                    """Extract raw data from value, handling dict wrappers."""
+                    if isinstance(val, dict) and "data" in val:
+                        return val["data"]
+                    if isinstance(val, list):
+                        return val
+                    return None
+
+                # Convert args to serializable format
+                args = to_json_serializable(call.args)
+
+                # Extract x, y data from args
+                if args:
+                    if len(args) >= 2:
+                        x_data = extract_data(args[0])
+                        y_data = extract_data(args[1])
+                        if x_data:
+                            call_data["x"] = x_data
+                        if y_data:
+                            call_data["y"] = y_data
+                    elif len(args) == 1:
+                        data = extract_data(args[0])
+                        if data:
+                            call_data["y"] = data
+                            call_data["x"] = list(range(len(call_data["y"])))
+
+                # Extract from kwargs
+                kwargs = to_json_serializable(call.kwargs)
+                for key in ["x", "y", "height", "width", "c", "s"]:
+                    if key in kwargs:
+                        val = extract_data(kwargs[key])
+                        if val:
+                            call_data[key] = val
+
+                if call_data:
+                    all_data[call_id] = call_data
+
+        if not all_data:
+            return jsonify({"error": "No plot data found"}), 400
+
+        # Create CSV content
+        output = io.StringIO()
+
+        # Find max length for padding
+        max_len = max(max(len(v) for v in data.values()) for data in all_data.values())
+
+        # Write header
+        headers = []
+        for call_id, data in all_data.items():
+            for key in sorted(data.keys()):
+                headers.append(f"{call_id}_{key}")
+
+        writer = csv.writer(output)
+        writer.writerow(headers)
+
+        # Write data rows
+        for i in range(max_len):
+            row = []
+            for call_id, data in all_data.items():
+                for key in sorted(data.keys()):
+                    values = data[key]
+                    if i < len(values):
+                        row.append(values[i])
+                    else:
+                        row.append("")
+            writer.writerow(row)
+
+        # Return CSV file
+        csv_content = output.getvalue().encode("utf-8")
+        filename = "figure_data.csv"
+        if editor.recipe_path:
+            filename = f"{editor.recipe_path.stem}_data.csv"
+
+        return send_file(
+            io.BytesIO(csv_content),
+            mimetype="text/csv",
+            as_attachment=True,
+            download_name=filename,
+        )
+
+    @app.route("/download/<fmt>")
+    def download(fmt: str):
+        """Download figure in specified format."""
+        import io
+
+        fmt = fmt.lower()
+        if fmt not in ("png", "svg", "pdf"):
+            return jsonify({"error": f"Unsupported format: {fmt}"}), 400
+
+        effective_style = editor.get_effective_style()
+        content = render_download(
+            editor.fig,
+            fmt=fmt,
+            dpi=300,
+            overrides=effective_style if effective_style else None,
+            dark_mode=False,
+        )
+
+        mimetype = {
+            "png": "image/png",
+            "svg": "image/svg+xml",
+            "pdf": "application/pdf",
+        }[fmt]
+
+        filename = f"figure.{fmt}"
+        if editor.recipe_path:
+            filename = f"{editor.recipe_path.stem}.{fmt}"
+
+        return send_file(
+            io.BytesIO(content),
+            mimetype=mimetype,
+            as_attachment=True,
+            download_name=filename,
+        )
+
+    @app.route("/shutdown", methods=["POST"])
+    def shutdown():
+        """Shutdown the server."""
+        func = request.environ.get("werkzeug.server.shutdown")
+        if func:
+            func()
+        return jsonify({"success": True})
+
+
+__all__ = ["register_element_routes"]