scitex 2.5.0__py3-none-any.whl → 2.7.3__py3-none-any.whl

scitex/vis/editor/flask_editor/core.py

@@ -1,152 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# File: ./src/scitex/vis/editor/flask_editor/core.py
-"""Core WebEditor class for Flask-based figure editing."""
-
-from pathlib import Path
-from typing import Dict, Any, Optional
-import copy
-import json
-import threading
-import webbrowser
-
-from .utils import find_available_port, kill_process_on_port, check_port_available
-from .renderer import render_preview_with_bboxes
-from .templates import build_html_template
-
-
-class WebEditor:
-    """
-    Browser-based figure editor using Flask.
-
-    Features:
-    - Modern responsive UI
-    - Real-time preview via WebSocket or polling
-    - Property editors with sliders and color pickers
-    - Save to .manual.json
-    - SciTeX style defaults pre-filled
-    - Auto-finds available port if default is in use
-    """
-
-    def __init__(
-        self,
-        json_path: Path,
-        metadata: Dict[str, Any],
-        csv_data: Optional[Any] = None,
-        png_path: Optional[Path] = None,
-        manual_overrides: Optional[Dict[str, Any]] = None,
-        port: int = 5050,
-    ):
-        self.json_path = Path(json_path)
-        self.metadata = metadata
-        self.csv_data = csv_data
-        self.png_path = Path(png_path) if png_path else None
-        self.manual_overrides = manual_overrides or {}
-        self._requested_port = port
-        self.port = port
-
-        # Get SciTeX defaults and merge with metadata
-        from .._defaults import get_scitex_defaults, extract_defaults_from_metadata
-        self.scitex_defaults = get_scitex_defaults()
-        self.metadata_defaults = extract_defaults_from_metadata(metadata)
-
-        # Start with defaults, then overlay manual overrides
-        self.current_overrides = copy.deepcopy(self.scitex_defaults)
-        self.current_overrides.update(self.metadata_defaults)
-        self.current_overrides.update(self.manual_overrides)
-
-        # Track initial state to detect modifications
-        self._initial_overrides = copy.deepcopy(self.current_overrides)
-        self._user_modified = False
-
-    def run(self):
-        """Launch the web editor."""
-        try:
-            from flask import Flask, render_template_string, request, jsonify
-        except ImportError:
-            raise ImportError("Flask is required for web editor. Install: pip install flask")
-
-        # Handle port conflicts
-        if not check_port_available(self._requested_port):
-            print(f"Port {self._requested_port} is in use. Attempting to free it...")
-            if kill_process_on_port(self._requested_port):
-                import time
-                time.sleep(0.5)
-                self.port = self._requested_port
-                print(f"Successfully freed port {self.port}")
-            else:
-                self.port = find_available_port(self._requested_port + 1)
-                print(f"Using alternative port: {self.port}")
-        else:
-            self.port = self._requested_port
-
-        app = Flask(__name__)
-        editor = self
-        html_template = build_html_template()
-
-        @app.route('/')
-        def index():
-            return render_template_string(
-                html_template,
-                filename=str(editor.json_path.resolve()),
-                overrides=json.dumps(editor.current_overrides)
-            )
-
-        @app.route('/preview')
-        def preview():
-            """Generate figure preview as base64 PNG with element bboxes."""
-            img_data, bboxes, img_size = render_preview_with_bboxes(
-                editor.csv_data, editor.current_overrides
-            )
-            return jsonify({'image': img_data, 'bboxes': bboxes, 'img_size': img_size})
-
-        @app.route('/update', methods=['POST'])
-        def update():
-            """Update overrides and return new preview."""
-            data = request.json
-            editor.current_overrides.update(data.get('overrides', {}))
-            editor._user_modified = True
-            img_data, bboxes, img_size = render_preview_with_bboxes(
-                editor.csv_data, editor.current_overrides
-            )
-            return jsonify({
-                'image': img_data,
-                'bboxes': bboxes,
-                'img_size': img_size,
-                'status': 'updated'
-            })
-
-        @app.route('/save', methods=['POST'])
-        def save():
-            """Save to .manual.json."""
-            from .._edit import save_manual_overrides
-            try:
-                manual_path = save_manual_overrides(editor.json_path, editor.current_overrides)
-                return jsonify({'status': 'saved', 'path': str(manual_path)})
-            except Exception as e:
-                return jsonify({'status': 'error', 'message': str(e)}), 500
-
-        @app.route('/shutdown', methods=['POST'])
-        def shutdown():
-            """Shutdown the server."""
-            func = request.environ.get('werkzeug.server.shutdown')
-            if func is None:
-                raise RuntimeError('Not running with Werkzeug Server')
-            func()
-            return jsonify({'status': 'shutdown'})
-
-        # Open browser after short delay
-        def open_browser():
-            import time
-            time.sleep(0.5)
-            webbrowser.open(f'http://127.0.0.1:{self.port}')
-
-        threading.Thread(target=open_browser, daemon=True).start()
-
-        print(f"Starting SciTeX Editor at http://127.0.0.1:{self.port}")
-        print("Press Ctrl+C to stop")
-
-        app.run(host='127.0.0.1', port=self.port, debug=False, use_reloader=False)
-
-
-# EOF

scitex/vis/editor/flask_editor/plotter.py

@@ -1,130 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# File: ./src/scitex/vis/editor/flask_editor/plotter.py
-"""CSV plotting functionality for Flask editor."""
-
-from typing import Dict, Any, Optional
-import pandas as pd
-
-
-def plot_from_csv(ax, csv_data: Optional[pd.DataFrame], overrides: Dict[str, Any], linewidth: float = 1.0):
-    """Reconstruct plot from CSV data using trace info from overrides.
-
-    Args:
-        ax: Matplotlib axes object
-        csv_data: DataFrame containing CSV data
-        overrides: Dictionary with override settings including traces
-        linewidth: Default line width in points
-    """
-    if csv_data is None or not isinstance(csv_data, pd.DataFrame):
-        return
-
-    df = csv_data
-    o = overrides
-
-    # Get legend settings from overrides
-    legend_fontsize = o.get('legend_fontsize', 6)
-    legend_visible = o.get('legend_visible', True)
-    legend_frameon = o.get('legend_frameon', False)
-    legend_loc = o.get('legend_loc', 'best')
-    legend_x = o.get('legend_x', 0.5)
-    legend_y = o.get('legend_y', 0.5)
-
-    # Get traces from overrides (which may have been edited by user)
-    traces = o.get('traces', [])
-
-    if traces:
-        _plot_with_traces(ax, df, traces, linewidth, legend_fontsize, legend_visible,
-                         legend_frameon, legend_loc, legend_x, legend_y)
-    else:
-        _plot_fallback(ax, df, linewidth, legend_fontsize, legend_visible,
-                      legend_frameon, legend_loc, legend_x, legend_y)
-
-
-def _plot_with_traces(ax, df, traces, linewidth, legend_fontsize, legend_visible,
-                     legend_frameon, legend_loc, legend_x, legend_y):
-    """Plot using trace information from overrides."""
-    for trace in traces:
-        csv_cols = trace.get('csv_columns', {})
-        x_col = csv_cols.get('x')
-        y_col = csv_cols.get('y')
-
-        if x_col in df.columns and y_col in df.columns:
-            ax.plot(
-                df[x_col],
-                df[y_col],
-                label=trace.get('label', trace.get('id', '')),
-                color=trace.get('color'),
-                linestyle=trace.get('linestyle', '-'),
-                linewidth=trace.get('linewidth', linewidth),
-                marker=trace.get('marker', None),
-                markersize=trace.get('markersize', 6),
-            )
-
-    # Add legend if there are labeled traces
-    if legend_visible and any(t.get('label') for t in traces):
-        _add_legend(ax, legend_fontsize, legend_frameon, legend_loc, legend_x, legend_y)
-
-
-def _plot_fallback(ax, df, linewidth, legend_fontsize, legend_visible,
-                  legend_frameon, legend_loc, legend_x, legend_y):
-    """Fallback plotting when no trace info available - smart parsing of column names."""
-    cols = df.columns.tolist()
-
-    # Group columns by trace ID
-    trace_groups = {}
-    for col in cols:
-        if col.endswith('_x'):
-            trace_id = col[:-2]  # Remove '_x'
-            y_col = trace_id + '_y'
-            if y_col in cols:
-                # Extract label from column name (e.g., ax_00_sine_plot -> sine)
-                parts = trace_id.split('_')
-                label = parts[2] if len(parts) > 2 else trace_id
-                trace_groups[trace_id] = {
-                    'x_col': col,
-                    'y_col': y_col,
-                    'label': label,
-                }
-
-    if trace_groups:
-        for trace_id, info in trace_groups.items():
-            ax.plot(
-                df[info['x_col']],
-                df[info['y_col']],
-                label=info['label'],
-                linewidth=linewidth,
-            )
-        if legend_visible:
-            _add_legend(ax, legend_fontsize, legend_frameon, legend_loc, legend_x, legend_y)
-
-    elif len(cols) >= 2:
-        # Last resort: assume first column is x, rest are y
-        x_col = cols[0]
-        for y_col in cols[1:]:
-            try:
-                ax.plot(df[x_col], df[y_col], label=str(y_col), linewidth=linewidth)
-            except Exception:
-                pass
-        if len(cols) > 2 and legend_visible:
-            _add_legend(ax, legend_fontsize, legend_frameon, legend_loc, legend_x, legend_y)
-
-
-def _add_legend(ax, fontsize, frameon, loc, x, y):
-    """Add legend to axes with specified settings."""
-    if loc == 'custom':
-        ax.legend(
-            fontsize=fontsize,
-            frameon=frameon,
-            loc='upper left',
-            bbox_to_anchor=(x, y),
-        )
-    else:
-        ax.legend(
-            fontsize=fontsize,
-            frameon=frameon,
-            loc=loc,
-        )
-
-
-# EOF

scitex/vis/editor/flask_editor/renderer.py

@@ -1,184 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# File: ./src/scitex/vis/editor/flask_editor/renderer.py
-"""Figure rendering for Flask editor."""
-
-from typing import Dict, Any, Tuple
-import base64
-import io
-
-import matplotlib
-matplotlib.use('Agg')
-import matplotlib.pyplot as plt
-from matplotlib.ticker import MaxNLocator
-from PIL import Image
-
-from .plotter import plot_from_csv
-from .bbox import extract_bboxes
-
-# mm to pt conversion factor
-MM_TO_PT = 2.83465
-
-
-def render_preview_with_bboxes(csv_data, overrides: Dict[str, Any], axis_fontsize: int = 7
-                               ) -> Tuple[str, Dict[str, Any], Dict[str, int]]:
-    """Render figure and return base64 PNG along with element bounding boxes.
-
-    Args:
-        csv_data: DataFrame containing CSV data
-        overrides: Dictionary with override settings
-        axis_fontsize: Default font size for axis labels
-
-    Returns:
-        tuple: (base64_image_data, bboxes_dict, image_size)
-    """
-    o = overrides
-
-    # Dimensions
-    dpi = o.get('dpi', 300)
-    fig_size = o.get('fig_size', [3.15, 2.68])
-
-    # Font sizes
-    axis_fontsize = o.get('axis_fontsize', 7)
-    tick_fontsize = o.get('tick_fontsize', 7)
-    title_fontsize = o.get('title_fontsize', 8)
-
-    # Line/axis thickness
-    linewidth_pt = o.get('linewidth', 0.57)
-    axis_width_pt = o.get('axis_width', 0.2) * MM_TO_PT
-    tick_length_pt = o.get('tick_length', 0.8) * MM_TO_PT
-    tick_width_pt = o.get('tick_width', 0.2) * MM_TO_PT
-    tick_direction = o.get('tick_direction', 'out')
-    x_n_ticks = o.get('x_n_ticks', o.get('n_ticks', 4))
-    y_n_ticks = o.get('y_n_ticks', o.get('n_ticks', 4))
-    hide_x_ticks = o.get('hide_x_ticks', False)
-    hide_y_ticks = o.get('hide_y_ticks', False)
-
-    transparent = o.get('transparent', True)
-
-    # Create figure
-    fig, ax = plt.subplots(figsize=fig_size, dpi=dpi)
-    _apply_background(fig, ax, o, transparent)
-
-    # Plot from CSV data
-    if csv_data is not None:
-        plot_from_csv(ax, csv_data, overrides, linewidth=linewidth_pt)
-    else:
-        ax.text(0.5, 0.5, "No plot data available\n(CSV not found)",
-               ha='center', va='center', transform=ax.transAxes,
-               fontsize=axis_fontsize)
-
-    # Apply labels
-    _apply_labels(ax, o, title_fontsize, axis_fontsize)
-
-    # Tick styling
-    _apply_tick_styling(ax, tick_fontsize, tick_length_pt, tick_width_pt, tick_direction,
-                        x_n_ticks, y_n_ticks, hide_x_ticks, hide_y_ticks)
-
-    # Apply grid, limits, spines
-    _apply_style(ax, o, axis_width_pt)
-
-    # Apply annotations
-    _apply_annotations(ax, o, axis_fontsize)
-
-    fig.tight_layout()
-
-    # Get element bounding boxes BEFORE saving (need renderer)
-    fig.canvas.draw()
-    renderer = fig.canvas.get_renderer()
-
-    # Save to buffer first to get actual image size
-    buf = io.BytesIO()
-    fig.savefig(buf, format='png', dpi=dpi, bbox_inches='tight', transparent=transparent)
-    buf.seek(0)
-
-    # Get actual saved image dimensions
-    img = Image.open(buf)
-    img_width, img_height = img.size
-    buf.seek(0)
-
-    # Get bboxes
-    bboxes = extract_bboxes(fig, ax, renderer, img_width, img_height)
-
-    img_data = base64.b64encode(buf.read()).decode('utf-8')
-    plt.close(fig)
-
-    return img_data, bboxes, {'width': img_width, 'height': img_height}
-
-
-def _apply_background(fig, ax, o, transparent):
-    """Apply background settings to figure."""
-    if transparent:
-        fig.patch.set_facecolor('none')
-        ax.patch.set_facecolor('none')
-    elif o.get('facecolor'):
-        fig.patch.set_facecolor(o['facecolor'])
-        ax.patch.set_facecolor(o['facecolor'])
-
-
-def _apply_labels(ax, o, title_fontsize, axis_fontsize):
-    """Apply title and axis labels."""
-    if o.get('title'):
-        ax.set_title(o['title'], fontsize=title_fontsize)
-    if o.get('xlabel'):
-        ax.set_xlabel(o['xlabel'], fontsize=axis_fontsize)
-    if o.get('ylabel'):
-        ax.set_ylabel(o['ylabel'], fontsize=axis_fontsize)
-
-
-def _apply_tick_styling(ax, tick_fontsize, tick_length_pt, tick_width_pt, tick_direction,
-                        x_n_ticks, y_n_ticks, hide_x_ticks, hide_y_ticks):
-    """Apply tick styling to axes."""
-    ax.tick_params(
-        axis='both',
-        labelsize=tick_fontsize,
-        length=tick_length_pt,
-        width=tick_width_pt,
-        direction=tick_direction,
-    )
-
-    if hide_x_ticks:
-        ax.xaxis.set_ticks([])
-        ax.xaxis.set_ticklabels([])
-    else:
-        ax.xaxis.set_major_locator(MaxNLocator(nbins=x_n_ticks))
-    if hide_y_ticks:
-        ax.yaxis.set_ticks([])
-        ax.yaxis.set_ticklabels([])
-    else:
-        ax.yaxis.set_major_locator(MaxNLocator(nbins=y_n_ticks))
-
-
-def _apply_style(ax, o, axis_width_pt):
-    """Apply grid, axis limits, and spine settings."""
-    if o.get('grid'):
-        ax.grid(True, linewidth=axis_width_pt, alpha=0.3)
-
-    if o.get('xlim'):
-        ax.set_xlim(o['xlim'])
-    if o.get('ylim'):
-        ax.set_ylim(o['ylim'])
-
-    if o.get('hide_top_spine', True):
-        ax.spines['top'].set_visible(False)
-    if o.get('hide_right_spine', True):
-        ax.spines['right'].set_visible(False)
-
-    for spine in ax.spines.values():
-        spine.set_linewidth(axis_width_pt)
-
-
-def _apply_annotations(ax, o, axis_fontsize):
-    """Apply text annotations to figure."""
-    for annot in o.get('annotations', []):
-        if annot.get('type') == 'text':
-            ax.text(
-                annot.get('x', 0.5),
-                annot.get('y', 0.5),
-                annot.get('text', ''),
-                transform=ax.transAxes,
-                fontsize=annot.get('fontsize', axis_fontsize),
-            )
-
-
-# EOF