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

figrecipe/_dev/demo_plotters/__init__.py

@@ -9,6 +9,11 @@ Usage
 >>> # List all available plot types
 >>> print(list(REGISTRY.keys()))
 >>>
+>>> # List by category
+>>> from figrecipe._dev.demo_plotters import CATEGORIES
+>>> for cat, plots in CATEGORIES.items():
+...     print(f"{cat}: {plots}")
+>>>
 >>> # Create a single figure with all plot types
 >>> fig, axes = create_all_plots_figure(fr)
 >>>
@@ -16,180 +21,44 @@ Usage
 >>> fig, ax = REGISTRY['plot'](fr, rng, ax)
 """
 
-import importlib
-import math
-from pathlib import Path
-from typing import Callable, Dict, Optional, Tuple
-
-import numpy as np
-
-# Registry: plot_name -> plotter function
-REGISTRY: Dict[str, Callable] = {}
-
-# Get all plot_*.py files in this directory
-_demo_dir = Path(__file__).parent
-_demo_files = sorted(_demo_dir.glob("plot_*.py"))
-
-# Import all demo functions into registry
-for _file in _demo_files:
-    _module_name = _file.stem  # e.g., plot_scatter
-    _plot_name = _module_name.replace("plot_", "")  # e.g., scatter
-    _func_name = _module_name  # e.g., plot_scatter
-    try:
-        _module = importlib.import_module(f".{_module_name}", package=__name__)
-        if hasattr(_module, _func_name):
-            REGISTRY[_plot_name] = getattr(_module, _func_name)
-    except ImportError as e:
-        print(f"Warning: Could not import {_module_name}: {e}")
-
-
-def list_plots():
-    """List all available plot types.
-
-    Returns
-    -------
-    list of str
-        Names of available plot types.
-    """
-    return list(REGISTRY.keys())
-
-
-def get_plotter(name: str) -> Optional[Callable]:
-    """Get plotter function by name.
-
-    Parameters
-    ----------
-    name : str
-        Plot type name (e.g., 'scatter', 'bar', 'hist').
-
-    Returns
-    -------
-    callable or None
-        Plotter function or None if not found.
-    """
-    return REGISTRY.get(name)
-
-
-def create_all_plots_figure(plt, seed: int = 42) -> Tuple:
-    """Create a single figure with all supported plot types.
-
-    Parameters
-    ----------
-    plt : module
-        figrecipe module (import figrecipe as fr).
-    seed : int
-        Random seed for reproducibility.
-
-    Returns
-    -------
-    tuple
-        (fig, axes) where fig is RecordingFigure and axes is array of RecordingAxes.
-    """
-    rng = np.random.default_rng(seed)
-
-    n_plots = len(REGISTRY)
-    ncols = 7
-    nrows = math.ceil(n_plots / ncols)
-
-    fig, axes = plt.subplots(nrows=nrows, ncols=ncols)
-    axes_flat = axes.flatten()
-
-    results = {}
-    for i, (name, plotter) in enumerate(REGISTRY.items()):
-        ax = axes_flat[i]
-        try:
-            plotter(plt, rng, ax=ax)
-            results[name] = {"success": True, "error": None}
-        except Exception as e:
-            ax.set_title(f"{name}\n(ERROR)")
-            ax.text(
-                0.5,
-                0.5,
-                str(e)[:50],
-                ha="center",
-                va="center",
-                transform=ax.transAxes,
-                fontsize=6,
-                wrap=True,
-            )
-            results[name] = {"success": False, "error": str(e)}
-
-    # Hide unused axes
-    for i in range(n_plots, len(axes_flat)):
-        axes_flat[i].set_visible(False)
-
-    # Add panel labels
-    panel_labels = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" * 2  # 52 labels
-    for i, ax in enumerate(axes_flat[:n_plots]):
-        if i < len(panel_labels):
-            plt.panel_label(ax, panel_labels[i])
-
-    fig.suptitle(f"All {n_plots} Supported Plot Types")
-
-    return fig, axes, results
-
-
-def run_individual_demos(plt, output_dir=None, show=False):
-    """Run all demo plotters individually and optionally save outputs.
-
-    Parameters
-    ----------
-    plt : module
-        figrecipe or matplotlib.pyplot module.
-    output_dir : Path, optional
-        Directory to save output images.
-    show : bool
-        Whether to show figures.
-
-    Returns
-    -------
-    dict
-        Results for each demo: {name: {'success': bool, 'error': str or None}}
-    """
-    rng = np.random.default_rng(42)
-    results = {}
-
-    if output_dir:
-        output_dir = Path(output_dir)
-        output_dir.mkdir(parents=True, exist_ok=True)
-
-    for name, plotter in REGISTRY.items():
-        try:
-            fig, ax = plotter(plt, rng)
-            if output_dir:
-                out_path = output_dir / f"plot_{name}.png"
-                if hasattr(fig, "fig"):
-                    fig.fig.savefig(out_path, dpi=100, bbox_inches="tight")
-                else:
-                    fig.savefig(out_path, dpi=100, bbox_inches="tight")
-            if show:
-                plt.show()
-            else:
-                if hasattr(fig, "fig"):
-                    plt.close(fig.fig)
-                else:
-                    plt.close(fig)
-            results[name] = {"success": True, "error": None}
-        except Exception as e:
-            results[name] = {"success": False, "error": str(e)}
-
-    return results
-
+from ._categories import CATEGORIES, CATEGORY_DISPLAY_NAMES, REPRESENTATIVES
+from ._figure_creators import (
+    create_all_plots_figure,
+    run_all_demos,
+    run_individual_demos,
+)
+from ._helpers import (
+    get_plotter,
+    get_representative_plots,
+    list_plots,
+    list_plots_by_category,
+)
+from ._registry import REGISTRY
 
 # Legacy exports for backwards compatibility
-__all__ = [f"plot_{name}" for name in REGISTRY.keys()]
+__all__ = [
+    "REGISTRY",
+    "CATEGORIES",
+    "CATEGORY_DISPLAY_NAMES",
+    "REPRESENTATIVES",
+    "list_plots",
+    "list_plots_by_category",
+    "get_representative_plots",
+    "get_plotter",
+    "create_all_plots_figure",
+    "run_individual_demos",
+    "run_all_demos",
+]
+
+# Legacy: export plot_* functions to globals
 for _name, _func in REGISTRY.items():
     globals()[f"plot_{_name}"] = _func
+    __all__.append(f"plot_{_name}")
 
 
 def list_demos():
     """Legacy: List all available demo functions."""
-    return __all__
-
-
-def run_all_demos(plt, output_dir=None, show=False):
-    """Legacy: Alias for run_individual_demos."""
-    return run_individual_demos(plt, output_dir, show)
+    return [f"plot_{name}" for name in REGISTRY.keys()]
 
 
 # EOF

figrecipe/_dev/demo_plotters/_categories.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Plot categories for organized display."""
+
+from typing import Dict, List
+
+from ._registry import REGISTRY
+
+# Plot categories for organized display
+# Keys match directory names in demo_plotters/
+_CATEGORIES_RAW: Dict[str, List[str]] = {
+    "line_curve": [
+        "plot",
+        "step",
+        "fill",
+        "fill_between",
+        "fill_betweenx",
+        "errorbar",
+        "stackplot",
+        "stairs",
+    ],
+    "scatter_points": ["scatter"],
+    "bar_categorical": ["bar", "barh"],
+    "distribution": ["hist", "hist2d", "boxplot", "violinplot", "ecdf"],
+    "image_matrix": ["imshow", "matshow", "pcolor", "pcolormesh", "hexbin", "spy"],
+    "contour_surface": [
+        "contour",
+        "contourf",
+        "tricontour",
+        "tricontourf",
+        "tripcolor",
+        "triplot",
+    ],
+    "spectral_signal": [
+        "specgram",
+        "psd",
+        "csd",
+        "cohere",
+        "angle_spectrum",
+        "magnitude_spectrum",
+        "phase_spectrum",
+        "acorr",
+        "xcorr",
+    ],
+    "vector_flow": ["quiver", "barbs", "streamplot"],
+    "special": ["pie", "stem", "eventplot", "loglog", "semilogx", "semilogy"],
+}
+
+# Display names for categories (for UI/documentation)
+CATEGORY_DISPLAY_NAMES: Dict[str, str] = {
+    "line_curve": "Line & Curve",
+    "scatter_points": "Scatter & Points",
+    "bar_categorical": "Bar & Categorical",
+    "distribution": "Distribution",
+    "image_matrix": "2D Image & Matrix",
+    "contour_surface": "Contour & Surface",
+    "spectral_signal": "Spectral & Signal",
+    "vector_flow": "Vector & Flow",
+    "special": "Special",
+}
+
+# Filter categories to only include available plots
+CATEGORIES: Dict[str, List[str]] = {
+    cat: [p for p in plots if p in REGISTRY] for cat, plots in _CATEGORIES_RAW.items()
+}
+CATEGORIES = {cat: plots for cat, plots in CATEGORIES.items() if plots}
+
+# Representative plots (one per category)
+REPRESENTATIVES: Dict[str, str] = {
+    "line_curve": "plot",
+    "scatter_points": "scatter",
+    "bar_categorical": "bar",
+    "distribution": "hist",
+    "image_matrix": "imshow",
+    "contour_surface": "contourf",
+    "spectral_signal": "specgram",
+    "vector_flow": "quiver",
+    "special": "pie",
+}
+
+# EOF

figrecipe/_dev/demo_plotters/_figure_creators.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Figure creation functions for demo plotters."""
+
+import math
+from pathlib import Path
+from typing import Dict, Tuple
+
+import numpy as np
+
+from ._registry import REGISTRY
+
+
+def create_all_plots_figure(plt, seed: int = 42) -> Tuple:
+    """Create a single figure with all supported plot types.
+
+    Parameters
+    ----------
+    plt : module
+        figrecipe module (import figrecipe as fr).
+    seed : int
+        Random seed for reproducibility.
+
+    Returns
+    -------
+    tuple
+        (fig, axes, results) where results maps name to success/error.
+    """
+    rng = np.random.default_rng(seed)
+
+    n_plots = len(REGISTRY)
+    ncols = 7
+    nrows = math.ceil(n_plots / ncols)
+
+    fig, axes = plt.subplots(nrows=nrows, ncols=ncols)
+    axes_flat = axes.flatten()
+
+    results = {}
+    for i, (name, plotter) in enumerate(REGISTRY.items()):
+        ax = axes_flat[i]
+        try:
+            plotter(plt, rng, ax=ax)
+            results[name] = {"success": True, "error": None}
+        except Exception as e:
+            ax.set_title(f"{name}\n(ERROR)")
+            ax.text(
+                0.5,
+                0.5,
+                str(e)[:50],
+                ha="center",
+                va="center",
+                transform=ax.transAxes,
+                fontsize=6,
+                wrap=True,
+            )
+            results[name] = {"success": False, "error": str(e)}
+
+    # Hide unused axes
+    for i in range(n_plots, len(axes_flat)):
+        axes_flat[i].set_visible(False)
+
+    # Add panel labels
+    panel_labels = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" * 2
+    for i, ax in enumerate(axes_flat[:n_plots]):
+        if i < len(panel_labels):
+            plt.panel_label(ax, panel_labels[i])
+
+    fig.suptitle(f"All {n_plots} Supported Plot Types")
+
+    return fig, axes, results
+
+
+def run_individual_demos(plt, output_dir=None, show=False) -> Dict:
+    """Run all demo plotters individually and optionally save outputs.
+
+    Parameters
+    ----------
+    plt : module
+        figrecipe or matplotlib.pyplot module.
+    output_dir : Path, optional
+        Directory to save output images.
+    show : bool
+        Whether to show figures.
+
+    Returns
+    -------
+    dict
+        Results for each demo: {name: {'success': bool, 'error': str or None}}
+    """
+    rng = np.random.default_rng(42)
+    results = {}
+
+    if output_dir:
+        output_dir = Path(output_dir)
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+    for name, plotter in REGISTRY.items():
+        try:
+            fig, ax = plotter(plt, rng)
+            if output_dir:
+                out_path = output_dir / f"plot_{name}.png"
+                mpl_fig = fig.fig if hasattr(fig, "fig") else fig
+                mpl_fig.savefig(out_path, dpi=100, bbox_inches="tight")
+            if show:
+                plt.show()
+            else:
+                mpl_fig = fig.fig if hasattr(fig, "fig") else fig
+                plt.close(mpl_fig)
+            results[name] = {"success": True, "error": None}
+        except Exception as e:
+            results[name] = {"success": False, "error": str(e)}
+
+    return results
+
+
+# Legacy alias
+run_all_demos = run_individual_demos
+
+# EOF

figrecipe/_dev/demo_plotters/_helpers.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Helper functions for demo plotters."""
+
+from typing import Callable, Dict, List, Optional
+
+from ._categories import CATEGORIES, REPRESENTATIVES
+from ._registry import REGISTRY
+
+
+def list_plots() -> List[str]:
+    """List all available plot types."""
+    return list(REGISTRY.keys())
+
+
+def list_plots_by_category() -> Dict[str, List[str]]:
+    """List all available plot types organized by category."""
+    return CATEGORIES.copy()
+
+
+def get_representative_plots() -> List[str]:
+    """Get one representative plot from each category for demos."""
+    return [p for p in REPRESENTATIVES.values() if p in REGISTRY]
+
+
+def get_plotter(name: str) -> Optional[Callable]:
+    """Get plotter function by name."""
+    return REGISTRY.get(name)
+
+
+# EOF

figrecipe/_dev/demo_plotters/_registry.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Registry for demo plotter functions."""
+
+import importlib
+from pathlib import Path
+from typing import Callable, Dict
+
+# Registry: plot_name -> plotter function
+REGISTRY: Dict[str, Callable] = {}
+
+# Get demo directory
+_demo_dir = Path(__file__).parent
+
+# Category subdirectories
+_category_dirs = [
+    "line_curve",
+    "scatter_points",
+    "bar_categorical",
+    "distribution",
+    "image_matrix",
+    "contour_surface",
+    "spectral_signal",
+    "vector_flow",
+    "special",
+]
+
+# Collect all plot_*.py files from subdirectories
+_demo_files = []
+for _cat_dir in _category_dirs:
+    _cat_path = _demo_dir / _cat_dir
+    if _cat_path.is_dir():
+        _demo_files.extend(sorted(_cat_path.glob("plot_*.py")))
+
+# Import all demo functions into registry
+for _file in _demo_files:
+    _module_name = _file.stem  # e.g., plot_scatter
+    _plot_name = _module_name.replace("plot_", "")  # e.g., scatter
+    _func_name = _module_name  # e.g., plot_scatter
+    _cat_dir = _file.parent.name  # e.g., scatter_points
+    try:
+        _module = importlib.import_module(
+            f".{_cat_dir}.{_module_name}", package=__name__.rsplit(".", 1)[0]
+        )
+        if hasattr(_module, _func_name):
+            REGISTRY[_plot_name] = getattr(_module, _func_name)
+    except ImportError as e:
+        print(f"Warning: Could not import {_cat_dir}.{_module_name}: {e}")
+
+# EOF

figrecipe/_dev/demo_plotters/bar_categorical/__init__.py

@@ -0,0 +1,4 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Demo plotters for bar_categorical category."""
+

figrecipe/_dev/demo_plotters/contour_surface/__init__.py

@@ -0,0 +1,4 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Demo plotters for contour_surface category."""
+

figrecipe/_dev/demo_plotters/distribution/__init__.py

@@ -0,0 +1,4 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Demo plotters for distribution category."""
+

figrecipe/_dev/demo_plotters/image_matrix/__init__.py

@@ -0,0 +1,4 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Demo plotters for image_matrix category."""
+

figrecipe/_dev/demo_plotters/line_curve/__init__.py

@@ -0,0 +1,4 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Demo plotters for line_curve category."""
+

figrecipe/_dev/demo_plotters/{plot_plot.py → line_curve/plot_plot.py}

@@ -16,8 +16,9 @@ def plot_plot(plt, rng, ax=None):
         fig = ax.get_figure() if hasattr(ax, "get_figure") else ax.fig
 
     x = np.linspace(0, 2 * np.pi, 100)
-    ax.plot(x, np.sin(x), id="sin")
-    ax.plot(x, np.cos(x), id="cos")
+    ax.plot(x, np.sin(x), label="sin", id="sin")
+    ax.plot(x, np.cos(x), label="cos", id="cos")
+    ax.legend()
     ax.set_xlabel("X")
     ax.set_ylabel("Y")
     ax.set_title("plot")

figrecipe/_dev/demo_plotters/scatter_points/__init__.py

@@ -0,0 +1,4 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Demo plotters for scatter_points category."""
+

figrecipe/_dev/demo_plotters/special/__init__.py

@@ -0,0 +1,4 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Demo plotters for special category."""
+

figrecipe/_dev/demo_plotters/{plot_pie.py → special/plot_pie.py}

@@ -2,6 +2,8 @@
 # -*- coding: utf-8 -*-
 """pie: pie chart demo."""
 
+import matplotlib.pyplot as mpl_plt
+
 
 def plot_pie(plt, rng, ax=None):
     """Pie chart demo.
@@ -15,7 +17,9 @@ def plot_pie(plt, rng, ax=None):
 
     sizes = [35, 25, 20, 20]
     labels = ["A", "B", "C", "D"]
-    ax.pie(sizes, labels=labels, id="pie")
+    # Get colors from current style's color cycle
+    colors = mpl_plt.rcParams["axes.prop_cycle"].by_key()["color"][:4]
+    ax.pie(sizes, labels=labels, colors=colors, id="pie")
     ax.set_title("pie")
     return fig, ax
 

figrecipe/_dev/demo_plotters/spectral_signal/__init__.py

@@ -0,0 +1,4 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Demo plotters for spectral_signal category."""
+

figrecipe/_dev/demo_plotters/vector_flow/__init__.py

@@ -0,0 +1,4 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Demo plotters for vector_flow category."""
+