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

figrecipe/_editor/_plot_types_registry.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Registry for plot types using existing figrecipe infrastructure.
+
+Uses:
+- figrecipe._signatures for signature introspection
+- figrecipe._dev.demo_plotters._categories for plot type organization
+"""
+
+from typing import Any, Dict, List
+
+from .._dev.demo_plotters._categories import CATEGORIES as _PLOT_CATEGORIES
+from .._dev.demo_plotters._categories import (
+    CATEGORY_DISPLAY_NAMES as _PLOT_DISPLAY_NAMES,
+)
+from .._signatures import get_signature
+
+# Decoration methods to add to the selector
+DECORATION_METHODS: List[str] = [
+    "text",
+    "annotate",
+    "arrow",
+    "axhline",
+    "axvline",
+    "axhspan",
+    "axvspan",
+]
+
+# Combined categories: plots + decorations
+CATEGORIES: Dict[str, List[str]] = {
+    **_PLOT_CATEGORIES,
+    "decoration": DECORATION_METHODS,
+}
+
+CATEGORY_DISPLAY_NAMES: Dict[str, str] = {
+    **_PLOT_DISPLAY_NAMES,
+    "decoration": "Decoration & Annotation",
+}
+
+
+def _get_docstring(method_name: str) -> str:
+    """Get first line of docstring for a matplotlib method."""
+    try:
+        import matplotlib.pyplot as plt
+        from matplotlib.axes import Axes
+
+        # Try Axes method first, then plt
+        fn = getattr(Axes, method_name, None) or getattr(plt, method_name, None)
+        if fn and fn.__doc__:
+            # Get first non-empty line of docstring
+            first_line = fn.__doc__.strip().split("\n")[0].strip()
+            # Clean up and truncate if needed
+            if len(first_line) > 100:
+                first_line = first_line[:97] + "..."
+            return first_line
+    except Exception:
+        pass
+    return ""
+
+
+def get_plot_type_info(method_name: str) -> Dict[str, Any]:
+    """Get plot type information from existing signature infrastructure."""
+    sig = get_signature(method_name)
+
+    args = sig.get("args", [])
+    kwargs = sig.get("kwargs", {})
+
+    # Args that also exist in kwargs with defaults are actually optional
+    kwargs_with_defaults = {
+        k for k, v in kwargs.items() if v.get("default") is not None or "default" in v
+    }
+
+    # Format required and optional args
+    required_parts = []
+    optional_parts = []
+
+    for arg in args:
+        name = arg.get("name", "")
+        if name.startswith("*"):
+            continue
+        # Arg is optional if marked optional OR has a default in kwargs
+        is_optional = arg.get("optional", False) or name in kwargs_with_defaults
+        if is_optional:
+            optional_parts.append(name)
+        else:
+            required_parts.append(name)
+
+    required_str = ", ".join(required_parts) if required_parts else "data"
+    # Only show first 2 optional vars, deduplicated
+    optional_str = ", ".join(optional_parts[:2]) if optional_parts else ""
+
+    # Build hint string showing signature
+    hint_parts = []
+    for arg in args[:4]:
+        name = arg.get("name", "")
+        if name.startswith("*"):
+            continue
+        is_optional = arg.get("optional", False) or name in kwargs_with_defaults
+        if is_optional:
+            hint_parts.append(f"[{name}]")
+        else:
+            hint_parts.append(name)
+
+    if hint_parts:
+        hint = f"{method_name}({', '.join(hint_parts)})"
+    else:
+        hint = f"{method_name}(data)"
+
+    # Get docstring for tooltip
+    docstring = _get_docstring(method_name)
+
+    return {
+        "name": method_name,
+        "required": required_str,
+        "optional": optional_str,
+        "hint": hint,
+        "docstring": docstring,
+    }
+
+
+def get_all_plot_types() -> Dict[str, Dict[str, Any]]:
+    """Get all plot types organized by category."""
+    result = {}
+    for cat_key, plots in CATEGORIES.items():
+        label = CATEGORY_DISPLAY_NAMES.get(cat_key, cat_key)
+        result[cat_key] = {
+            "label": label,
+            "types": [get_plot_type_info(m) for m in plots],
+        }
+    return result
+
+
+def generate_html_options() -> str:
+    """Generate HTML <optgroup> and <option> elements for plot type selector.
+
+    Shows required and optional arguments with brackets around optional.
+    e.g., "fill_between (x, y1, [y2], [where])"
+    Includes docstring as tooltip on hover.
+    """
+    import html
+
+    html_parts = []
+    first = True
+    for cat_key, plots in CATEGORIES.items():
+        label = CATEGORY_DISPLAY_NAMES.get(cat_key, cat_key)
+        html_parts.append(f'                    <optgroup label="{label}">')
+        for method in plots:
+            info = get_plot_type_info(method)
+            # Use hint which has correct bracket notation
+            # hint format: "method(x, y, [opt1], [opt2])"
+            display_text = info["hint"]
+            selected = " selected" if first else ""
+            first = False
+            # Add docstring as title for tooltip
+            docstring = info.get("docstring", "")
+            title_attr = f' title="{html.escape(docstring)}"' if docstring else ""
+            html_parts.append(
+                f'                        <option value="{method}"{selected}{title_attr}>{display_text}</option>'
+            )
+        html_parts.append("                    </optgroup>")
+    return "\n".join(html_parts)
+
+
+def generate_js_hints() -> str:
+    """Generate JavaScript PLOT_TYPE_HINTS object from signature infrastructure."""
+    lines = ["const PLOT_TYPE_HINTS = {"]
+    for plots in CATEGORIES.values():
+        for method in plots:
+            info = get_plot_type_info(method)
+            req = info["required"].replace("'", "\\'")
+            opt = info["optional"].replace("'", "\\'")
+            hint = info["hint"].replace("'", "\\'")
+            doc = info.get("docstring", "").replace("'", "\\'")
+            lines.append(
+                f"    {method}: {{ required: '{req}', optional: '{opt}', hint: '{hint}', doc: '{doc}' }},"
+            )
+    lines.append("};")
+    return "\n".join(lines)
+
+
+__all__ = [
+    "CATEGORIES",
+    "CATEGORY_DISPLAY_NAMES",
+    "get_plot_type_info",
+    "get_all_plot_types",
+    "generate_html_options",
+    "generate_js_hints",
+]
+
+# EOF

figrecipe/_editor/_preferences.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""User preferences management for the figure editor.
+
+Preferences are stored in ~/.figrecipe/preferences.json and persist
+across sessions. This allows users to set defaults like dark mode.
+"""
+
+import json
+from pathlib import Path
+from typing import Any, Dict
+
+# Default preferences
+DEFAULT_PREFERENCES = {
+    "dark_mode": False,
+    "default_style": "SCITEX",
+    "auto_save": True,
+    "show_hit_regions": False,
+}
+
+# Preferences file location
+PREFERENCES_DIR = Path.home() / ".figrecipe"
+PREFERENCES_FILE = PREFERENCES_DIR / "preferences.json"
+
+
+def get_preferences_path() -> Path:
+    """Get the path to the preferences file."""
+    return PREFERENCES_FILE
+
+
+def load_preferences() -> Dict[str, Any]:
+    """Load user preferences from disk.
+
+    Returns
+    -------
+    dict
+        User preferences merged with defaults.
+    """
+    prefs = DEFAULT_PREFERENCES.copy()
+
+    if PREFERENCES_FILE.exists():
+        try:
+            with open(PREFERENCES_FILE, "r") as f:
+                saved = json.load(f)
+                prefs.update(saved)
+        except (json.JSONDecodeError, IOError):
+            # If file is corrupted, use defaults
+            pass
+
+    return prefs
+
+
+def save_preferences(prefs: Dict[str, Any]) -> bool:
+    """Save user preferences to disk.
+
+    Parameters
+    ----------
+    prefs : dict
+        Preferences to save.
+
+    Returns
+    -------
+    bool
+        True if save was successful.
+    """
+    try:
+        PREFERENCES_DIR.mkdir(parents=True, exist_ok=True)
+        with open(PREFERENCES_FILE, "w") as f:
+            json.dump(prefs, f, indent=2)
+        return True
+    except IOError:
+        return False
+
+
+def get_preference(key: str, default: Any = None) -> Any:
+    """Get a single preference value.
+
+    Parameters
+    ----------
+    key : str
+        Preference key.
+    default : Any, optional
+        Default value if key not found.
+
+    Returns
+    -------
+    Any
+        Preference value.
+    """
+    prefs = load_preferences()
+    return prefs.get(key, default)
+
+
+def set_preference(key: str, value: Any) -> bool:
+    """Set a single preference value.
+
+    Parameters
+    ----------
+    key : str
+        Preference key.
+    value : Any
+        Value to set.
+
+    Returns
+    -------
+    bool
+        True if save was successful.
+    """
+    prefs = load_preferences()
+    prefs[key] = value
+    return save_preferences(prefs)
+
+
+def reset_preferences() -> bool:
+    """Reset all preferences to defaults.
+
+    Returns
+    -------
+    bool
+        True if reset was successful.
+    """
+    return save_preferences(DEFAULT_PREFERENCES.copy())
+
+
+__all__ = [
+    "DEFAULT_PREFERENCES",
+    "get_preferences_path",
+    "load_preferences",
+    "save_preferences",
+    "get_preference",
+    "set_preference",
+    "reset_preferences",
+]
+
+# EOF