feat(letsplot): implement roc-curve (#2315)

## Implementation: `roc-curve` - letsplot

Implements the **letsplot** version of `roc-curve`.

**File:** `plots/roc-curve/implementations/letsplot.py`

---
:robot: *[impl-generate
workflow](https://github.com/MarkusNeusinger/pyplots/actions/runs/20526599354)*

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

Author: github-actions[bot]

plots/roc-curve/implementations/letsplot.py

@@ -0,0 +1,100 @@
+""" pyplots.ai
+roc-curve: ROC Curve with AUC
+Library: letsplot 4.8.2 | Python 3.13.11
+Quality: 92/100 | Created: 2025-12-26
+"""
+
+import numpy as np
+import pandas as pd
+from lets_plot import *  # noqa: F403
+from lets_plot import ggsave
+
+LetsPlot.setup_html()  # noqa: F405
+
+# Data - Generate ROC curve data for multiple classifiers
+np.random.seed(42)
+
+# Generate synthetic classification scores
+n_samples = 1000
+y_true = np.concatenate([np.zeros(500), np.ones(500)])
+
+# Model A - Good classifier (AUC ~0.92)
+scores_a = np.concatenate(
+    [
+        np.random.beta(2, 5, 500),  # Negative class
+        np.random.beta(5, 2, 500),  # Positive class
+    ]
+)
+
+# Model B - Moderate classifier (AUC ~0.78)
+scores_b = np.concatenate(
+    [
+        np.random.beta(2, 3, 500),  # Negative class
+        np.random.beta(3, 2, 500),  # Positive class
+    ]
+)
+
+
+# Calculate ROC curve points
+def compute_roc(y_true, scores):
+    thresholds = np.linspace(0, 1, 200)
+    tpr_list = []
+    fpr_list = []
+    for thresh in thresholds:
+        predictions = (scores >= thresh).astype(int)
+        tp = np.sum((predictions == 1) & (y_true == 1))
+        fn = np.sum((predictions == 0) & (y_true == 1))
+        fp = np.sum((predictions == 1) & (y_true == 0))
+        tn = np.sum((predictions == 0) & (y_true == 0))
+        tpr = tp / (tp + fn) if (tp + fn) > 0 else 0
+        fpr = fp / (fp + tn) if (fp + tn) > 0 else 0
+        tpr_list.append(tpr)
+        fpr_list.append(fpr)
+    return np.array(fpr_list), np.array(tpr_list)
+
+
+# Compute ROC curves
+fpr_a, tpr_a = compute_roc(y_true, scores_a)
+fpr_b, tpr_b = compute_roc(y_true, scores_b)
+
+# Calculate AUC using trapezoidal rule
+auc_a = -np.trapezoid(tpr_a, fpr_a)
+auc_b = -np.trapezoid(tpr_b, fpr_b)
+
+# Create DataFrames for plotting
+df_model_a = pd.DataFrame({"fpr": fpr_a, "tpr": tpr_a, "model": f"Model A (AUC = {auc_a:.2f})"})
+
+df_model_b = pd.DataFrame({"fpr": fpr_b, "tpr": tpr_b, "model": f"Model B (AUC = {auc_b:.2f})"})
+
+# Random classifier reference line
+df_random = pd.DataFrame({"fpr": [0, 1], "tpr": [0, 1], "model": "Random (AUC = 0.50)"})
+
+# Combine all data
+df = pd.concat([df_model_a, df_model_b, df_random], ignore_index=True)
+
+# Plot
+plot = (
+    ggplot(df, aes(x="fpr", y="tpr", color="model"))
+    + geom_line(size=2)
+    + scale_color_manual(values=["#306998", "#FFD43B", "#888888"])
+    + scale_x_continuous(limits=[0, 1])
+    + scale_y_continuous(limits=[0, 1])
+    + coord_fixed(ratio=1)
+    + labs(
+        x="False Positive Rate", y="True Positive Rate", title="roc-curve · letsplot · pyplots.ai", color="Classifier"
+    )
+    + theme_minimal()
+    + theme(
+        plot_title=element_text(size=24),
+        axis_title=element_text(size=20),
+        axis_text=element_text(size=16),
+        legend_text=element_text(size=16),
+        legend_title=element_text(size=18),
+        legend_position="bottom",
+    )
+    + ggsize(1600, 900)
+)
+
+# Save as PNG (scale 3x = 4800 x 2700 px) and HTML
+ggsave(plot, "plot.png", path=".", scale=3)
+ggsave(plot, "plot.html", path=".")

plots/roc-curve/metadata/letsplot.yaml

@@ -0,0 +1,26 @@
+library: letsplot
+specification_id: roc-curve
+created: '2025-12-26T17:39:54Z'
+updated: '2025-12-26T17:50:14Z'
+generated_by: claude-opus-4-5-20251101
+workflow_run: 20526599354
+issue: 0
+python_version: 3.13.11
+library_version: 4.8.2
+preview_url: https://storage.googleapis.com/pyplots-images/plots/roc-curve/letsplot/plot.png
+preview_thumb: https://storage.googleapis.com/pyplots-images/plots/roc-curve/letsplot/plot_thumb.png
+preview_html: https://storage.googleapis.com/pyplots-images/plots/roc-curve/letsplot/plot.html
+quality_score: 92
+review:
+  strengths:
+  - Excellent visual clarity with properly sized text elements and colorblind-safe
+    palette
+  - Correct implementation of ROC curve with all required features (diagonal reference,
+    AUC in legend, multiple models)
+  - Uses coord_fixed(ratio=1) for equal aspect ratio as recommended in spec
+  - Clean ggplot grammar of graphics approach with appropriate theme customization
+  - Proper scale 3x export for 4800x2700 resolution
+  weaknesses:
+  - Code contains a function definition (compute_roc) which violates the KISS principle
+    - should be inline calculations
+  - Grid alpha not explicitly set (could be more subtle)