like-sci-figures 0.0.0-stage → 1.0.0

package/scripts/render_utils.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+"""Shared rendering utilities for palette_picker.py and showcase.py.
+
+Why this exists
+---------------
+Before this file existed, palette_picker.py and showcase.py each had a copy
+of:
+
+    _p()             path join helper
+    _load_fonts()    CJK font detection with the same candidate list
+    _render_chart()  subprocess wrapper that calls gen_figure.py
+    compose_grid()   Pillow canvas + header + cell-paste pattern
+
+That was ~200 lines of duplicated code. This module is the single home for
+those utilities, so both poster scripts can focus on what they actually do
+(choosing which charts to render, arranging the grid) rather than re-
+implementing the rendering plumbing.
+
+Public API
+----------
+    join(*parts)          -> absolute path
+    load_fonts()         -> (dict[size->Font], used_path)
+    render_chart(...)    -> (out_path, error, elapsed_seconds)
+    compose_grid(...)    -> canvas Image (composes thumbnails into a grid)
+"""
+import os
+import subprocess
+import sys
+import time
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+SKILL_DIR = os.path.dirname(SCRIPT_DIR)
+GEN = os.path.join(SCRIPT_DIR, "gen_figure.py")
+PYTHON = sys.executable
+
+
+def join(*parts):
+    """Join path parts and return the absolute path."""
+    return os.path.abspath(os.path.join(*[str(p) for p in parts]))
+
+
+def load_fonts(sizes=(30, 26, 20, 17, 14, 12, 10)):
+    """Load CJK-capable fonts at several sizes.
+
+    Returns (fonts_dict, used_path) where fonts_dict maps size -> ImageFont.
+    Falls back to the system default font if no CJK-capable file is found.
+    """
+    from PIL import ImageFont
+    candidates = []
+    try:
+        from font_detector import detect_cjk_font
+        det = detect_cjk_font()
+        if det:
+            candidates.append(det)
+    except Exception:
+        pass
+    candidates += [
+        os.environ.get("FONT_PATH", ""),
+        r"C:/Windows/Fonts/msyh.ttc",
+        r"C:/Windows/Fonts/msyh.ttf",
+        r"C:/Windows/Fonts/simsun.ttc",
+        "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
+    ]
+    used = None
+    fonts = {}
+    for size in sizes:
+        f = None
+        for path in candidates:
+            if path and os.path.exists(path):
+                try:
+                    f = ImageFont.truetype(path, size)
+                except Exception:
+                    continue
+                if f is not None:
+                    break
+        fonts[size] = f
+        if used is None and f is not None:
+            used = getattr(f, "path", None)
+    return fonts, used
+
+
+def render_chart(chart_type, data_path, out_path, style="nature",
+                 palette=None, width=3.2, height=2.4, dpi=120,
+                 timeout=120, extra_args=None):
+    """Render one chart via gen_figure.py.
+
+    Returns (out_path_or_None, error_or_None, elapsed_seconds).
+    out_path is None (and error set) if the render failed.
+    """
+    t0 = time.time()
+    cmd = [PYTHON, GEN,
+           "--type", chart_type,
+           "--data", data_path,
+           "--out", out_path,
+           "--style", style,
+           "--width", str(width),
+           "--height", str(height),
+           "--dpi", str(dpi)]
+    if palette:
+        cmd += ["--palette", palette]
+    if extra_args:
+        cmd += list(extra_args)
+    try:
+        proc = subprocess.run(cmd, capture_output=True, text=True,
+                              timeout=timeout)
+        dt = time.time() - t0
+        if proc.returncode != 0 or not os.path.exists(out_path) \
+                or os.path.getsize(out_path) == 0:
+            return None, (proc.stderr or "").strip()[-300:], dt
+        return out_path, None, dt
+    except Exception as exc:
+        return None, str(exc), time.time() - t0
+
+
+def compose_grid(thumbnails, chart_order, header_text, subtitle_text,
+                 cols, cell_w=360, cell_h=280, label_h=28,
+                 gap=10, pad=16, header_h=72, footer_text=None,
+                 author_tag="LIKE Sci Figures"):
+    """Compose a grid of chart thumbnails into a single poster canvas.
+
+    thumbnails: dict[chart_type -> png_path]
+    chart_order: ordered list of chart types (determines grid layout)
+    header_text / subtitle_text: lines for the green header band
+    cols: number of columns (rows computed from len(chart_order))
+    author_tag: text displayed at the bottom-right corner of the header (e.g. "LIKE")
+    footer_text: optional line at the bottom
+
+    Returns the composed PIL Image (caller is responsible for .save()).
+    """
+    import math
+    from PIL import Image, ImageDraw, ImageFont
+
+    n = len(chart_order)
+    rows = max(1, int(math.ceil(n / cols)))
+
+    width = cols * cell_w + (cols - 1) * gap + 2 * pad
+    height = (header_h + rows * (cell_h + label_h)
+              + (rows - 1) * gap + 2 * pad
+              + (40 if footer_text else 0))
+
+    canvas = Image.new("RGB", (width, height), "white")
+    d = ImageDraw.Draw(canvas)
+    fonts, font_used = load_fonts((22, 18, 14, 12, 10))
+    f22 = fonts.get(22) or ImageFont.load_default()
+    f18 = fonts.get(18) or ImageFont.load_default()
+    f14 = fonts.get(14) or ImageFont.load_default()
+    f12 = fonts.get(12) or ImageFont.load_default()
+
+    # header
+    d.rectangle([0, 0, width, header_h], fill="#0B6E4F")
+    d.text((pad + 2, 10), header_text, fill="white", font=f22)
+    d.text((pad + 2, 42), subtitle_text, fill="#D7E1EB", font=f14)
+
+    # author tag at the bottom-right corner of the header band
+    if author_tag:
+        bbox = d.textbbox((0, 0), author_tag, font=f18)
+        tag_w = bbox[2] - bbox[0]
+        d.text((width - pad - tag_w - 2, header_h - 28),
+               author_tag, fill="#D7E1EB", font=f18)
+
+    # cells
+    for idx, chart_type in enumerate(chart_order):
+        col = idx % cols
+        row = idx // cols
+        x = pad + col * (cell_w + gap)
+        y = header_h + pad + row * (cell_h + label_h + gap)
+
+        d.rectangle([x, y, x + cell_w, y + cell_h],
+                    fill="white", outline="#DDDDDD")
+        png = thumbnails.get(chart_type)
+        if png and os.path.exists(png):
+            im = Image.open(png).convert("RGB")
+            if im.width != cell_w or im.height != cell_h:
+                im = im.resize((cell_w, cell_h), Image.LANCZOS)
+            canvas.paste(im, (x, y))
+        else:
+            d.text((x + 10, y + cell_h // 2 - 10), "渲染失败",
+                   fill="#999999", font=f14)
+
+        from registry import ZH_NAME
+        label = "%s  (%s)" % (ZH_NAME.get(chart_type, chart_type),
+                              chart_type)
+        d.text((x + 4, y + cell_h + 4), label, fill="#111111", font=f14)
+
+    if footer_text:
+        d.text((pad, height - 30), footer_text, fill="#555555", font=f12)
+
+    return canvas
+
+
+# ── palette_pref integration ───────────────────────────────────────────────
+STATE_REL = os.path.join(".workbuddy", "like-sci-figures", "palette.json")
+AUTO_SENTINEL = "auto"
+
+
+def read_palette_state(state_path=None, cwd=None):
+    """Read the task-scoped palette preference, if any.
+
+    Returns (palette_slug_or_None, state_file_path). palette is None when no
+    record exists; the string "auto" when the user explicitly opted out.
+    """
+    import json
+    if state_path is None:
+        state_path = os.path.join(cwd or os.getcwd(), STATE_REL)
+    state_path = os.path.abspath(state_path)
+    if not os.path.exists(state_path):
+        return None, state_path
+    try:
+        with open(state_path, "r", encoding="utf-8") as fh:
+            rec = json.load(fh)
+        value = (rec or {}).get("palette")
+        return (value if value else None), state_path
+    except Exception:
+        return None, state_path
+
+
+def write_palette_state(slug, state_path=None, cwd=None):
+    """Persist the user's palette choice for the current task."""
+    import json
+    import time
+    if state_path is None:
+        state_path = os.path.join(cwd or os.getcwd(), STATE_REL)
+    state_path = os.path.abspath(state_path)
+    os.makedirs(os.path.dirname(state_path), exist_ok=True)
+    rec = {
+        "palette": slug,
+        "chosen_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+        "cwd": os.getcwd(),
+    }
+    with open(state_path, "w", encoding="utf-8") as fh:
+        json.dump(rec, fh, ensure_ascii=False, indent=2)
+        fh.write("\n")
+    return state_path

package/scripts/showcase.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""Render every chart type with one palette + one style and stitch a showcase.
+
+Why this exists
+---------------
+After the user picks a palette (via palette_picker.py) and a style, they want
+to see what that combination looks like across *all* chart types — not just
+the 5 representative ones in the picker poster. This script:
+
+    1. Renders each of the 36 chart types from examples/ with the chosen
+       palette and style (calling gen_figure.py for real).
+    2. Stitches the thumbnails into a single grid PNG.
+    3. Writes a manifest.json listing what was rendered, with per-chart
+       timings and output sizes.
+
+The user can then present the grid to the user as a "here's what every chart
+will look like with your choice" preview.
+
+Usage
+-----
+    showcase.py                                 # defaults: --style nature
+    showcase.py --palette wx06_amber_navy --style ieee
+    showcase.py --palette p6 --style science --out outputs/my-showcase.png
+    showcase.py --dry-run                       # show plan, render nothing
+
+Notes
+-----
+* The grid layout is auto-computed: ceil(sqrt(n)) columns for a near-square
+  grid, with per-chart Chinese labels.
+* Requires Pillow. Thumbnails need only matplotlib (via gen_figure.py).
+* Chart-type → example mapping lives in registry.py; shared rendering helpers
+  live in render_utils.py. This module only owns the showcase-specific layout.
+"""
+import argparse
+import json
+import math
+import os
+import sys
+import tempfile
+import time
+from concurrent.futures import ThreadPoolExecutor
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, SCRIPT_DIR)
+
+from registry import CHART_EXAMPLES, example_path, ZH_NAME
+from render_utils import render_chart, compose_grid
+
+SKILL_DIR = os.path.dirname(SCRIPT_DIR)
+DEFAULT_OUT = os.path.join(SKILL_DIR, "references", "showcase.png")
+
+
+def generate(out_path, palette=None, style="nature", workers=4,
+             overwrite=False, dry_run=False):
+    """Render all chart types and compose the showcase grid + manifest."""
+    chart_order = sorted(CHART_EXAMPLES)
+
+    if dry_run:
+        print("would render %d charts (%s)"
+              % (len(chart_order), ", ".join(chart_order)))
+        return 0
+    if out_path and os.path.exists(out_path) and not overwrite:
+        print("(showcase already exists, skipped — use --force to rebuild)")
+        print(out_path)
+        return 0
+
+    tmpdir = tempfile.mkdtemp(prefix="sf_showcase_")
+    thumbs = {}
+    manifest = {
+        "style": style,
+        "palette": palette,
+        "generated_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+        "charts": [],
+    }
+
+    def _do(args):
+        chart_type, data_path = args
+        png, err, dt = render_chart(
+            chart_type, data_path,
+            os.path.join(tmpdir, "%s.png" % chart_type),
+            style=style, palette=palette,
+            width=3.2, height=2.4, dpi=120)
+        return chart_type, png, err, dt
+
+    with ThreadPoolExecutor(max_workers=workers) as pool:
+        for chart_type, out_png, err, dt in pool.map(
+                _do,
+                [(ct, example_path(ct)) for ct in chart_order]
+                if all(example_path(ct) for ct in chart_order)
+                else [(ct, example_path(ct)) for ct in chart_order
+                      if example_path(ct)]):
+            if out_png:
+                thumbs[chart_type] = out_png
+                manifest["charts"].append({
+                    "type": chart_type,
+                    "zh": ZH_NAME.get(chart_type, chart_type),
+                    "example": CHART_EXAMPLES[chart_type],
+                    "output": os.path.basename(out_png),
+                    "bytes": os.path.getsize(out_png),
+                    "seconds": round(dt, 2),
+                    "status": "ok",
+                })
+            else:
+                manifest["charts"].append({
+                    "type": chart_type,
+                    "zh": ZH_NAME.get(chart_type, chart_type),
+                    "example": CHART_EXAMPLES[chart_type],
+                    "output": None,
+                    "bytes": 0,
+                    "seconds": round(dt, 2),
+                    "status": "failed",
+                    "error": err,
+                })
+
+    # ── compose grid ─────────────────────────────────────────────────────
+    n = len(chart_order)
+    cols = max(1, int(math.ceil(math.sqrt(n))))
+    canvas = compose_grid(
+        thumbnails=thumbs,
+        chart_order=chart_order,
+        header_text="LIKE Sci Figures — Showcase  ·  %s  ×  %s"
+                    % (style, palette or "(default)"),
+        subtitle_text="%d chart types · %s"
+                      % (n, manifest["generated_at"]),
+        cols=cols,
+        cell_w=360, cell_h=280, label_h=28, gap=10, pad=16, header_h=72,
+        footer_text=None,
+    )
+
+    # ── save ─────────────────────────────────────────────────────────────
+    os.makedirs(os.path.dirname(out_path) or ".", exist_ok=True)
+    canvas.save(out_path, dpi=(160, 160))
+
+    manifest_path = os.path.splitext(out_path)[0] + ".manifest.json"
+    with open(manifest_path, "w", encoding="utf-8") as fh:
+        json.dump(manifest, fh, ensure_ascii=False, indent=2)
+        fh.write("\n")
+
+    ok_count = sum(1 for c in manifest["charts"] if c["status"] == "ok")
+    fail_count = sum(1 for c in manifest["charts"] if c["status"] == "failed")
+    if fail_count:
+        print("WARNING: %d chart(s) failed to render" % fail_count,
+              file=sys.stderr)
+        for c in manifest["charts"]:
+            if c["status"] == "failed":
+                print("   %s: %s" % (c["type"], c.get("error", "?")),
+                      file=sys.stderr)
+    print("Showcase grid: %s  (%d x %d px, %d bytes)"
+          % (out_path, canvas.width, canvas.height,
+             os.path.getsize(out_path)))
+    print("Manifest:      %s" % manifest_path)
+    print("Charts rendered: %d ok, %d failed" % (ok_count, fail_count))
+    return 0 if fail_count == 0 else 1
+
+
+def main():
+    ap = argparse.ArgumentParser(
+        prog="showcase.py",
+        description="Render every chart type with one palette + style into "
+                    "a single grid poster, plus a manifest.json.")
+    ap.add_argument("--out", default=DEFAULT_OUT,
+                    help="Grid PNG output (default: references/showcase.png)")
+    ap.add_argument("--palette", "-p", default=None,
+                    help="Palette slug/alias to showcase (default: none)")
+    ap.add_argument("--style", "-s", default="nature",
+                    help="Journal style (default: %(default)s)")
+    ap.add_argument("--workers", type=int, default=4, help="Parallel renders")
+    ap.add_argument("--force", action="store_true",
+                    help="Rebuild even if the poster already exists")
+    ap.add_argument("--dry-run", action="store_true",
+                    help="Print what would be rendered and exit")
+    args = ap.parse_args()
+    return generate(args.out, palette=args.palette, style=args.style,
+                    workers=args.workers, overwrite=args.force,
+                    dry_run=args.dry_run) or 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/style_manager.py

@@ -0,0 +1,267 @@
+#!/usr/bin/env python3
+"""
+Style manager for like-sci-figures skill.
+Integrates scienceplots library with fallback built-in styles.
+"""
+import matplotlib.pyplot as plt
+import warnings
+
+# scienceplots style aliases map to their actual style names
+SCIENCEPLOTS_STYLES = [
+    "ieee",
+    "nature",
+    "springer",
+    "aaas",
+    "science",
+    "lancet",
+    "acs",
+    "aps",
+    "cell",
+    "nejm",
+    "mdpi",
+]
+
+# Built-in fallback styles that approximate scienceplots when it's not installed
+# Each entry: (name, rc_params_dict)
+BUILTIN_STYLES = {
+    "ieee": {
+        "figure.figsize": (6.5, 4.5),
+        "figure.dpi": 300,
+        "font.size": 8,
+        "font.family": "serif",
+        "axes.titlesize": 9,
+        "axes.labelsize": 8,
+        "axes.linewidth": 0.8,
+        "xtick.labelsize": 7,
+        "ytick.labelsize": 7,
+        "lines.linewidth": 1.2,
+        "grid.alpha": 0.3,
+        "grid.linestyle": "--",
+    },
+    "nature": {
+        "figure.figsize": (7, 5),
+        "figure.dpi": 300,
+        "font.size": 7,
+        "font.family": "sans-serif",
+        "axes.titlesize": 8,
+        "axes.labelsize": 7,
+        "axes.linewidth": 0.6,
+        "xtick.labelsize": 6,
+        "ytick.labelsize": 6,
+        "lines.linewidth": 1.0,
+        "grid.alpha": 0.2,
+    },
+    "springer": {
+        "figure.figsize": (7.8, 5.2),
+        "figure.dpi": 300,
+        "font.size": 8,
+        "font.family": "serif",
+        "axes.titlesize": 9,
+        "axes.labelsize": 8,
+        "axes.linewidth": 0.7,
+        "xtick.labelsize": 7,
+        "ytick.labelsize": 7,
+        "lines.linewidth": 1.1,
+        "grid.alpha": 0.3,
+    },
+    "aaas": {
+        "figure.figsize": (5.5, 4),
+        "figure.dpi": 300,
+        "font.size": 7,
+        "font.family": "sans-serif",
+        "axes.titlesize": 8,
+        "axes.labelsize": 7,
+        "axes.linewidth": 0.5,
+        "xtick.labelsize": 6,
+        "ytick.labelsize": 6,
+        "lines.linewidth": 1.0,
+    },
+    "science": {
+        "figure.figsize": (5.5, 4.5),
+        "figure.dpi": 300,
+        "font.size": 7,
+        "font.family": "sans-serif",
+        "axes.titlesize": 8,
+        "axes.labelsize": 7,
+        "axes.linewidth": 0.5,
+        "xtick.labelsize": 6,
+        "ytick.labelsize": 6,
+        "lines.linewidth": 1.0,
+    },
+    "lancet": {
+        "figure.figsize": (8, 5.5),
+        "figure.dpi": 300,
+        "font.size": 9,
+        "font.family": "serif",
+        "axes.titlesize": 10,
+        "axes.labelsize": 9,
+        "axes.linewidth": 0.8,
+        "xtick.labelsize": 8,
+        "ytick.labelsize": 8,
+        "lines.linewidth": 1.3,
+    },
+    "acs": {
+        "figure.figsize": (6, 4.5),
+        "figure.dpi": 300,
+        "font.size": 8,
+        "font.family": "sans-serif",
+        "axes.titlesize": 9,
+        "axes.labelsize": 8,
+        "axes.linewidth": 0.8,
+        "xtick.labelsize": 7,
+        "ytick.labelsize": 7,
+        "lines.linewidth": 1.2,
+    },
+    "aps": {
+        "figure.figsize": (6.5, 4.5),
+        "figure.dpi": 300,
+        "font.size": 8,
+        "font.family": "serif",
+        "axes.titlesize": 9,
+        "axes.labelsize": 8,
+        "axes.linewidth": 0.7,
+        "xtick.labelsize": 7,
+        "ytick.labelsize": 7,
+        "lines.linewidth": 1.1,
+    },
+    "cell": {
+        "figure.figsize": (7, 5),
+        "figure.dpi": 300,
+        "font.size": 8,
+        "font.family": "sans-serif",
+        "axes.titlesize": 9,
+        "axes.labelsize": 8,
+        "axes.linewidth": 0.8,
+        "xtick.labelsize": 7,
+        "ytick.labelsize": 7,
+        "lines.linewidth": 1.2,
+        "grid.alpha": 0.25,
+    },
+    "nejm": {
+        "figure.figsize": (6, 4.5),
+        "figure.dpi": 300,
+        "font.size": 8,
+        "font.family": "sans-serif",
+        "axes.titlesize": 9,
+        "axes.labelsize": 8,
+        "axes.linewidth": 0.8,
+        "xtick.labelsize": 7,
+        "ytick.labelsize": 7,
+        "lines.linewidth": 1.3,
+        "grid.alpha": 0.3,
+    },
+    "mdpi": {
+        "figure.figsize": (7.5, 5),
+        "figure.dpi": 300,
+        "font.size": 9,
+        "font.family": "sans-serif",
+        "axes.titlesize": 10,
+        "axes.labelsize": 9,
+        "axes.linewidth": 0.8,
+        "xtick.labelsize": 8,
+        "ytick.labelsize": 8,
+        "lines.linewidth": 1.3,
+        "grid.alpha": 0.3,
+    },
+}
+
+# Color palettes per journal style
+COLOR_PALETTES = {
+    "ieee": ["#0072BD", "#D95319", "#EDB120", "#7E2F8E", "#77AC30", "#4DBEEE", "#A2142F"],
+    "nature": ["#E64B35", "#4DBBD5", "#00A087", "#3C5488", "#F39B7F", "#8491B4", "#91D1C2", "#DC0000"],
+    "springer": ["#00468B", "#ED0000", "#42B540", "#0099B4", "#925E9F", "#FDAF91", "#AD002A", "#1B1919"],
+    "aaas": ["#3B4992", "#EE0000", "#008B45", "#631879", "#008280", "#BB0021", "#5F559B", "#A20056"],
+    "science": ["#3B4992", "#EE0000", "#008B45", "#631879", "#008280", "#BB0021"],
+    "lancet": ["#00468B", "#ED0000", "#42B540", "#0099B4", "#525252", "#7F6F00", "#ED7D31"],
+    "acs": ["#E37222", "#07889B", "#66B9BF", "#EEAA7B", "#155265", "#E3A41B", "#7F7F7F"],
+    "aps": ["#0072B2", "#D55E00", "#009E73", "#CC79A7", "#F0E442", "#56B4E9"],
+    "cell": ["#3B4992", "#EE0000", "#008B45", "#631879", "#008280", "#BB0021", "#5F559B"],
+    "nejm": ["#1F77B4", "#D62728", "#2CA02C", "#9467BD", "#FF7F0E", "#17BECF", "#BCBD22"],
+    "mdpi": ["#E37222", "#07889B", "#66B9BF", "#EEAA7B", "#155265", "#E3A41B", "#7F7F7F"],
+}
+
+DEFAULT_STYLE = "nature"
+SCIENCEPLOTS_AVAILABLE = False
+SCIENCEPLOTS_UNREACHABLE = False
+
+
+def _check_scienceplots():
+    """Check if scienceplots is available and can be imported."""
+    global SCIENCEPLOTS_AVAILABLE, SCIENCEPLOTS_UNREACHABLE
+    if SCIENCEPLOTS_UNREACHABLE:
+        return False
+    try:
+        import scienceplots
+        SCIENCEPLOTS_AVAILABLE = True
+        return True
+    except ImportError:
+        SCIENCEPLOTS_AVAILABLE = False
+        SCIENCEPLOTS_UNREACHABLE = True
+        return False
+
+
+def setup_style(style_name=DEFAULT_STYLE, custom_rc=None):
+    """
+    Set up the matplotlib style for the given journal.
+
+    Args:
+        style_name: One of the SCIENCEPLOTS_STYLES
+        custom_rc: Optional dict of rcParams overrides
+
+    Returns:
+        dict with color palette and style metadata
+    """
+    style_name = style_name.lower().strip()
+    if style_name not in SCIENCEPLOTS_STYLES and style_name not in BUILTIN_STYLES:
+        print(f"Warning: Unknown style '{style_name}', falling back to 'nature'")
+        style_name = "nature"
+
+    # scienceplots only provides 3 secondary styles: ieee, nature, science
+    _SCIENCEPLOTS_REAL_STYLES = {"ieee", "nature", "science"}
+
+    if _check_scienceplots():
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            if style_name in _SCIENCEPLOTS_REAL_STYLES:
+                plt.style.use(["science", style_name])
+            else:
+                # Use "science" base + our built-in rc params for unsupported styles
+                plt.style.use("science")
+                rc = BUILTIN_STYLES.get(style_name, BUILTIN_STYLES["nature"])
+                plt.rcParams.update(rc)
+    else:
+        rc = BUILTIN_STYLES.get(style_name, BUILTIN_STYLES["nature"])
+        plt.rcParams.update(rc)
+
+    # Always apply a few quality defaults
+    # Disable LaTeX (usetex) to avoid LaTeX dependency issues;
+    # matplotlib's built-in mathtext handles math rendering fine.
+    # Also provide sans-serif fallbacks for serif fonts (Windows lacks Times).
+    plt.rcParams.update({
+        "text.usetex": False,
+        "font.serif": ["DejaVu Serif", "Times New Roman", "Times", "serif"],
+        "savefig.dpi": 300,
+        "savefig.bbox": "tight",
+        "savefig.pad_inches": 0.05,
+        "axes.unicode_minus": False,
+    })
+
+    # Apply any user overrides
+    if custom_rc:
+        plt.rcParams.update(custom_rc)
+
+    return {
+        "colors": COLOR_PALETTES.get(style_name, COLOR_PALETTES["nature"]),
+        "name": style_name,
+        "scienceplots_loaded": SCIENCEPLOTS_AVAILABLE,
+    }
+
+
+def list_styles():
+    """Return list of available style names."""
+    return SCIENCEPLOTS_STYLES[:]
+
+
+def reset_style():
+    """Reset matplotlib rcParams to defaults."""
+    plt.rcdefaults()