openrunner-sdk 0.4.0__tar.gz → 0.4.2__tar.gz

{openrunner_sdk-0.4.0 → openrunner_sdk-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrunner-sdk
-Version: 0.4.0
+Version: 0.4.2
 Summary: OpenRunner SDK - W&B-compatible ML experiment tracking client
 Project-URL: Homepage, https://github.com/jqueguiner/openrunner
 Project-URL: Repository, https://github.com/jqueguiner/openrunner

{openrunner_sdk-0.4.0 → openrunner_sdk-0.4.2}/openrunner/integration/huggingface.py

@@ -52,9 +52,17 @@ class OpenRunnerCallback(TrainerCallback):
         control: TrainerControl,
         **kwargs,
     ) -> None:
-        """Start a new run if one isn't already active."""
+        """Start a new run if one isn't already active.
+
+        If the user has already called ``openrunner.init()``, merges
+        training args into the existing config instead of creating
+        a new run.
+        """
         if openrunner._active_run is None:
-            openrunner.init(project=args.output_dir, config=args.to_dict())
+            openrunner.init(config=args.to_dict())
+        else:
+            # Merge trainer args into existing run config
+            openrunner.config.update(args.to_dict())
 
     def on_log(
         self,

{openrunner_sdk-0.4.0 → openrunner_sdk-0.4.2}/openrunner/integration/lightning.py

@@ -68,7 +68,12 @@ class OpenRunnerLogger(Logger):
 
     @property
     def experiment(self) -> Any:
-        """Return the underlying Run object (Lightning Logger protocol)."""
+        """Return the underlying Run object (Lightning Logger protocol).
+
+        Auto-initialises the run on first access so that
+        ``logger.experiment.config["key"] = val`` works before training.
+        """
+        self._ensure_run()
         return self._run
 
     # -- Core methods -------------------------------------------------------

openrunner_sdk-0.4.2/openrunner/integration/pytorch.py

@@ -0,0 +1,95 @@
+"""PyTorch integration for OpenRunner.
+
+Provides a ``log_gradients`` utility that logs gradient norms for all
+model parameters via ``openrunner.log()``.
+
+Usage::
+
+    from openrunner.integration.pytorch import log_gradients
+
+    for batch in dataloader:
+        loss = model(batch)
+        loss.backward()
+        log_gradients(model, step=step)
+        optimizer.step()
+
+Requires: ``pip install openrunner[pytorch]``
+"""
+
+from __future__ import annotations
+
+try:
+    import torch  # noqa: F401
+except ImportError:
+    raise ImportError(
+        "PyTorch integration requires torch. "
+        "Install with: pip install openrunner[pytorch]"
+    )
+
+import openrunner
+
+
+def watch(
+    model: torch.nn.Module,
+    log: str = "gradients",
+    log_freq: int = 100,
+    log_graph: bool = False,
+) -> None:
+    """Automatically log gradients and/or parameters of a model.
+
+    Registers a backward hook that logs gradient norms every
+    ``log_freq`` backward passes. Similar to ``wandb.watch()``.
+
+    Args:
+        model: A PyTorch ``nn.Module`` to watch.
+        log: What to log -- ``"gradients"``, ``"parameters"``, or ``"all"``.
+        log_freq: Log every N backward passes.
+        log_graph: Ignored (kept for W&B API compatibility).
+    """
+    _counter = {"n": 0}
+    log_grads = log in ("gradients", "all")
+    log_params = log in ("parameters", "all")
+
+    def _hook(module: torch.nn.Module, grad_input, grad_output) -> None:
+        _counter["n"] += 1
+        if _counter["n"] % log_freq != 0:
+            return
+        step = _counter["n"]
+        if log_grads:
+            for name, param in module.named_parameters():
+                if param.grad is not None:
+                    openrunner.log(
+                        {f"gradients/{name}.norm": param.grad.norm().item()},
+                        step=step,
+                        commit=False,
+                    )
+        if log_params:
+            for name, param in module.named_parameters():
+                openrunner.log(
+                    {f"parameters/{name}.norm": param.norm().item()},
+                    step=step,
+                    commit=False,
+                )
+        openrunner.log({}, step=step, commit=True)
+
+    model.register_full_backward_hook(_hook)
+
+
+def log_gradients(model: torch.nn.Module, step: int | None = None) -> None:
+    """Log gradient norms for all model parameters.
+
+    For each named parameter that has a gradient, logs the L2 norm
+    as ``gradients/{name}``.  Parameters whose ``.grad`` is ``None``
+    (e.g., frozen layers) are silently skipped.
+
+    Args:
+        model: A PyTorch ``nn.Module`` whose ``.backward()`` has been called.
+        step: Optional explicit step value passed to ``openrunner.log()``.
+    """
+    for name, param in model.named_parameters():
+        if param.grad is not None:
+            norm = param.grad.norm().item()
+            openrunner.log({f"gradients/{name}": norm}, step=step, commit=False)
+
+    # Commit the step after all gradient norms have been logged.
+    openrunner.log({}, step=step, commit=True)

openrunner_sdk-0.4.2/openrunner/integration/sklearn.py

@@ -0,0 +1,431 @@
+"""Scikit-learn integration for OpenRunner.
+
+Provides utility functions to log scikit-learn model information,
+classification reports, confusion matrices, and feature importances
+to an active OpenRunner run.
+
+Usage::
+
+    from openrunner.integration.sklearn import (
+        log_model,
+        log_classification_report,
+        log_confusion_matrix,
+        log_feature_importance,
+    )
+
+    model = RandomForestClassifier().fit(X_train, y_train)
+    log_model(model)
+    log_classification_report(y_test, y_pred)
+    log_confusion_matrix(y_test, y_pred)
+    log_feature_importance(model, feature_names=["f1", "f2", "f3"])
+
+Requires: ``pip install openrunner[sklearn]``
+"""
+
+from __future__ import annotations
+
+from typing import Any, Sequence
+
+try:
+    import sklearn  # noqa: F401
+except ImportError:
+    raise ImportError(
+        "Scikit-learn integration requires scikit-learn. "
+        "Install with: pip install openrunner[sklearn]"
+    )
+
+import openrunner
+
+
+def log_model(model: Any, name: str | None = None) -> None:
+    """Log model hyperparameters via ``get_params()``.
+
+    Logs all parameters returned by the model's ``get_params()`` method
+    into the run config under ``model/`` prefix.
+
+    Args:
+        model: A fitted scikit-learn estimator.
+        name: Optional model name stored in config.
+    """
+    if openrunner._active_run is None:
+        return
+
+    params = model.get_params()
+    prefixed = {f"model/{k}": v for k, v in params.items() if _is_loggable(v)}
+    if name:
+        prefixed["model/name"] = name
+    prefixed["model/class"] = type(model).__name__
+    if prefixed:
+        openrunner.config.update(prefixed)
+
+
+def log_classification_report(
+    y_true: Sequence,
+    y_pred: Sequence,
+    labels: Sequence | None = None,
+    target_names: Sequence[str] | None = None,
+) -> None:
+    """Log a classification report as a Table.
+
+    Uses ``sklearn.metrics.classification_report`` to compute precision,
+    recall, f1-score and support, then logs the result as an
+    ``openrunner.Table``.
+
+    Args:
+        y_true: Ground-truth labels.
+        y_pred: Predicted labels.
+        labels: Optional list of label indices to include.
+        target_names: Optional display names for each label.
+    """
+    if openrunner._active_run is None:
+        return
+
+    from sklearn.metrics import classification_report as _cr
+
+    report = _cr(
+        y_true,
+        y_pred,
+        labels=labels,
+        target_names=target_names,
+        output_dict=True,
+    )
+
+    columns = ["class", "precision", "recall", "f1-score", "support"]
+    data: list[list[Any]] = []
+    for cls_name, metrics in report.items():
+        if isinstance(metrics, dict):
+            data.append([
+                cls_name,
+                round(metrics.get("precision", 0), 4),
+                round(metrics.get("recall", 0), 4),
+                round(metrics.get("f1-score", 0), 4),
+                metrics.get("support", 0),
+            ])
+        else:
+            # scalar like "accuracy"
+            data.append([cls_name, metrics, None, None, None])
+
+    table = openrunner.Table(columns=columns, data=data)
+    openrunner.log({"classification_report": table})
+
+
+def log_confusion_matrix(
+    y_true: Sequence,
+    y_pred: Sequence,
+    labels: Sequence | None = None,
+    class_names: Sequence[str] | None = None,
+) -> None:
+    """Log a confusion matrix as an Image (matplotlib heatmap).
+
+    Generates a heatmap using ``matplotlib`` and logs it as an
+    ``openrunner.Image``.
+
+    Args:
+        y_true: Ground-truth labels.
+        y_pred: Predicted labels.
+        labels: Optional list of label values for ordering.
+        class_names: Optional display names for the axes.
+    """
+    if openrunner._active_run is None:
+        return
+
+    from sklearn.metrics import confusion_matrix as _cm
+
+    try:
+        import matplotlib
+        matplotlib.use("Agg")
+        import matplotlib.pyplot as plt
+    except ImportError:
+        raise ImportError(
+            "log_confusion_matrix requires matplotlib. "
+            "Install with: pip install matplotlib"
+        )
+
+    cm = _cm(y_true, y_pred, labels=labels)
+
+    fig, ax = plt.subplots(figsize=(6, 5))
+    im = ax.imshow(cm, interpolation="nearest", cmap="Blues")
+    fig.colorbar(im, ax=ax)
+
+    if class_names is not None:
+        tick_marks = list(range(len(class_names)))
+        ax.set_xticks(tick_marks)
+        ax.set_xticklabels(class_names, rotation=45, ha="right")
+        ax.set_yticks(tick_marks)
+        ax.set_yticklabels(class_names)
+
+    ax.set_xlabel("Predicted")
+    ax.set_ylabel("True")
+    ax.set_title("Confusion Matrix")
+    fig.tight_layout()
+
+    openrunner.log({"confusion_matrix": openrunner.Image(fig)})
+    plt.close(fig)
+
+
+def log_feature_importance(
+    model: Any,
+    feature_names: Sequence[str] | None = None,
+) -> None:
+    """Log feature importances as a Table.
+
+    Extracts ``feature_importances_`` from the model and logs them
+    as a sorted ``openrunner.Table`` (most important first).
+
+    Args:
+        model: A fitted scikit-learn estimator with
+            ``feature_importances_`` attribute.
+        feature_names: Optional list of feature names. If not
+            provided, uses ``feature_0``, ``feature_1``, etc.
+    """
+    if openrunner._active_run is None:
+        return
+
+    if not hasattr(model, "feature_importances_"):
+        return
+
+    importances = model.feature_importances_
+    if feature_names is None:
+        feature_names = [f"feature_{i}" for i in range(len(importances))]
+
+    # Sort by importance descending
+    pairs = sorted(
+        zip(feature_names, importances),
+        key=lambda x: x[1],
+        reverse=True,
+    )
+
+    columns = ["feature", "importance"]
+    data = [[name, round(float(imp), 6)] for name, imp in pairs]
+
+    table = openrunner.Table(columns=columns, data=data)
+    openrunner.log({"feature_importance": table})
+
+
+def log_learning_curve(
+    model: Any,
+    X: Any,
+    y: Any,
+    cv: int = 5,
+    scoring: str = "accuracy",
+) -> None:
+    """Log a learning curve as an Image.
+
+    Uses ``sklearn.model_selection.learning_curve`` and plots train/val
+    scores vs training set size.
+
+    Args:
+        model: A scikit-learn estimator.
+        X: Training features.
+        y: Training labels.
+        cv: Number of cross-validation folds.
+        scoring: Scoring metric name.
+    """
+    if openrunner._active_run is None:
+        return
+
+    from sklearn.model_selection import learning_curve as _lc
+
+    try:
+        import matplotlib
+        matplotlib.use("Agg")
+        import matplotlib.pyplot as plt
+    except ImportError:
+        raise ImportError(
+            "log_learning_curve requires matplotlib. "
+            "Install with: pip install matplotlib"
+        )
+
+    import numpy as np
+
+    train_sizes, train_scores, val_scores = _lc(
+        model, X, y, cv=cv, scoring=scoring,
+        train_sizes=np.linspace(0.1, 1.0, 8),
+    )
+
+    fig, ax = plt.subplots(figsize=(6, 4))
+    ax.plot(train_sizes, train_scores.mean(axis=1), "o-", label="Train")
+    ax.fill_between(
+        train_sizes,
+        train_scores.mean(axis=1) - train_scores.std(axis=1),
+        train_scores.mean(axis=1) + train_scores.std(axis=1),
+        alpha=0.15,
+    )
+    ax.plot(train_sizes, val_scores.mean(axis=1), "o-", label="Validation")
+    ax.fill_between(
+        train_sizes,
+        val_scores.mean(axis=1) - val_scores.std(axis=1),
+        val_scores.mean(axis=1) + val_scores.std(axis=1),
+        alpha=0.15,
+    )
+    ax.set_xlabel("Training Set Size")
+    ax.set_ylabel(scoring.capitalize())
+    ax.set_title("Learning Curve")
+    ax.legend(loc="best")
+    fig.tight_layout()
+
+    openrunner.log({"learning_curve": openrunner.Image(fig)})
+    plt.close(fig)
+
+
+def log_roc(
+    y_true: Sequence,
+    y_probas: Any,
+    labels: Sequence[str] | None = None,
+) -> None:
+    """Log ROC curves as an Image.
+
+    Computes per-class ROC curves using one-vs-rest strategy and
+    logs the plot as an ``openrunner.Image``.
+
+    Args:
+        y_true: Ground-truth labels.
+        y_probas: Predicted probabilities (shape: n_samples x n_classes).
+        labels: Optional class names for the legend.
+    """
+    if openrunner._active_run is None:
+        return
+
+    from sklearn.metrics import roc_curve, auc
+    from sklearn.preprocessing import label_binarize
+
+    try:
+        import matplotlib
+        matplotlib.use("Agg")
+        import matplotlib.pyplot as plt
+    except ImportError:
+        raise ImportError(
+            "log_roc requires matplotlib. Install with: pip install matplotlib"
+        )
+
+    import numpy as np
+
+    classes = np.unique(y_true)
+    n_classes = len(classes)
+
+    if n_classes == 2:
+        # Binary classification
+        fpr, tpr, _ = roc_curve(y_true, y_probas[:, 1] if y_probas.ndim > 1 else y_probas)
+        roc_auc = auc(fpr, tpr)
+        fig, ax = plt.subplots(figsize=(6, 5))
+        label_name = labels[1] if labels and len(labels) > 1 else "Positive"
+        ax.plot(fpr, tpr, label=f"{label_name} (AUC={roc_auc:.3f})")
+    else:
+        # Multi-class: one-vs-rest
+        y_bin = label_binarize(y_true, classes=classes)
+        fig, ax = plt.subplots(figsize=(6, 5))
+        for i in range(n_classes):
+            fpr, tpr, _ = roc_curve(y_bin[:, i], y_probas[:, i])
+            roc_auc = auc(fpr, tpr)
+            name = labels[i] if labels and i < len(labels) else str(classes[i])
+            ax.plot(fpr, tpr, label=f"{name} (AUC={roc_auc:.3f})")
+
+    ax.plot([0, 1], [0, 1], "k--", alpha=0.3)
+    ax.set_xlabel("False Positive Rate")
+    ax.set_ylabel("True Positive Rate")
+    ax.set_title("ROC Curve")
+    ax.legend(loc="lower right", fontsize=9)
+    fig.tight_layout()
+
+    openrunner.log({"roc_curve": openrunner.Image(fig)})
+    plt.close(fig)
+
+
+def log_precision_recall(
+    y_true: Sequence,
+    y_probas: Any,
+    labels: Sequence[str] | None = None,
+) -> None:
+    """Log precision-recall curves as an Image.
+
+    Args:
+        y_true: Ground-truth labels.
+        y_probas: Predicted probabilities (shape: n_samples x n_classes).
+        labels: Optional class names for the legend.
+    """
+    if openrunner._active_run is None:
+        return
+
+    from sklearn.metrics import precision_recall_curve, average_precision_score
+    from sklearn.preprocessing import label_binarize
+
+    try:
+        import matplotlib
+        matplotlib.use("Agg")
+        import matplotlib.pyplot as plt
+    except ImportError:
+        raise ImportError(
+            "log_precision_recall requires matplotlib. "
+            "Install with: pip install matplotlib"
+        )
+
+    import numpy as np
+
+    classes = np.unique(y_true)
+    n_classes = len(classes)
+
+    fig, ax = plt.subplots(figsize=(6, 5))
+
+    if n_classes == 2:
+        probs = y_probas[:, 1] if y_probas.ndim > 1 else y_probas
+        precision, recall, _ = precision_recall_curve(y_true, probs)
+        ap = average_precision_score(y_true, probs)
+        name = labels[1] if labels and len(labels) > 1 else "Positive"
+        ax.plot(recall, precision, label=f"{name} (AP={ap:.3f})")
+    else:
+        y_bin = label_binarize(y_true, classes=classes)
+        for i in range(n_classes):
+            precision, recall, _ = precision_recall_curve(y_bin[:, i], y_probas[:, i])
+            ap = average_precision_score(y_bin[:, i], y_probas[:, i])
+            name = labels[i] if labels and i < len(labels) else str(classes[i])
+            ax.plot(recall, precision, label=f"{name} (AP={ap:.3f})")
+
+    ax.set_xlabel("Recall")
+    ax.set_ylabel("Precision")
+    ax.set_title("Precision-Recall Curve")
+    ax.legend(loc="best", fontsize=9)
+    fig.tight_layout()
+
+    openrunner.log({"precision_recall": openrunner.Image(fig)})
+    plt.close(fig)
+
+
+def log_class_proportions(
+    y_train: Sequence,
+    y_test: Sequence,
+    labels: Sequence[str] | None = None,
+) -> None:
+    """Log class distribution as a Table.
+
+    Args:
+        y_train: Training labels.
+        y_test: Test labels.
+        labels: Optional class names.
+    """
+    if openrunner._active_run is None:
+        return
+
+    import numpy as np
+
+    classes = np.unique(np.concatenate([y_train, y_test]))
+    columns = ["class", "train_count", "test_count", "train_%", "test_%"]
+    data = []
+    for i, cls in enumerate(classes):
+        name = labels[i] if labels and i < len(labels) else str(cls)
+        train_ct = int(np.sum(np.array(y_train) == cls))
+        test_ct = int(np.sum(np.array(y_test) == cls))
+        data.append([
+            name,
+            train_ct,
+            test_ct,
+            round(train_ct / len(y_train) * 100, 1),
+            round(test_ct / len(y_test) * 100, 1),
+        ])
+
+    table = openrunner.Table(columns=columns, data=data)
+    openrunner.log({"class_proportions": table})
+
+
+def _is_loggable(value: Any) -> bool:
+    """Check if a value can be logged as a metric (numeric or string)."""
+    return isinstance(value, (int, float, str, bool))

{openrunner_sdk-0.4.0 → openrunner_sdk-0.4.2}/openrunner/run.py

@@ -83,6 +83,29 @@ class _TeeWriter:
         return getattr(self._original, name)
 
 
+class _LogCaptureHandler(logging.Handler):
+    """Captures Python logging output and sends it to OpenRunner console logs.
+
+    This catches output from frameworks that use `logging` instead of `print()`
+    (HuggingFace Transformers, PyTorch Lightning, etc.)
+    """
+
+    def __init__(self, sender) -> None:
+        super().__init__()
+        self._sender = sender
+        # Don't capture openrunner's own logs to avoid recursion
+        self.addFilter(lambda record: not record.name.startswith("openrunner"))
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            msg = self.format(record)
+            ts = datetime.now(timezone.utc).isoformat()
+            stream = "stderr" if record.levelno >= logging.WARNING else "stdout"
+            self._sender.add_console_line(ts, stream, msg)
+        except Exception:
+            pass
+
+
 def _generate_run_id() -> str:
     """Generate a W&B-style 8-character run ID."""
     return "".join(secrets.choice(_ALPHABET) for _ in range(8))
@@ -226,6 +249,10 @@ class Run:
         sys.stdout = _TeeWriter(sys.stdout, "stdout", self._sender)
         sys.stderr = _TeeWriter(sys.stderr, "stderr", self._sender)
 
+        # Also capture Python logging output (used by HuggingFace, PyTorch, etc.)
+        self._log_handler = _LogCaptureHandler(self._sender)
+        logging.root.addHandler(self._log_handler)
+
     # -- Properties -----------------------------------------------------------
 
     @property
@@ -668,6 +695,10 @@ class Run:
             exit_code: Optional exit code for the run.
             quiet: If True, suppress the finish message.
         """
+        # Remove logging handler
+        if hasattr(self, "_log_handler"):
+            logging.root.removeHandler(self._log_handler)
+
         # Restore original stdout/stderr before stopping sender
         if hasattr(self, "_original_stdout"):
             # Flush any remaining captured output

{openrunner_sdk-0.4.0 → openrunner_sdk-0.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "openrunner-sdk"
-version = "0.4.0"
+version = "0.4.2"
 description = "OpenRunner SDK - W&B-compatible ML experiment tracking client"
 readme = "README.md"
 license = {text = "MIT"}

openrunner_sdk-0.4.0/openrunner/integration/pytorch.py

@@ -1,49 +0,0 @@
-"""PyTorch integration for OpenRunner.
-
-Provides a ``log_gradients`` utility that logs gradient norms for all
-model parameters via ``openrunner.log()``.
-
-Usage::
-
-    from openrunner.integration.pytorch import log_gradients
-
-    for batch in dataloader:
-        loss = model(batch)
-        loss.backward()
-        log_gradients(model, step=step)
-        optimizer.step()
-
-Requires: ``pip install openrunner[pytorch]``
-"""
-
-from __future__ import annotations
-
-try:
-    import torch  # noqa: F401
-except ImportError:
-    raise ImportError(
-        "PyTorch integration requires torch. "
-        "Install with: pip install openrunner[pytorch]"
-    )
-
-import openrunner
-
-
-def log_gradients(model: torch.nn.Module, step: int | None = None) -> None:
-    """Log gradient norms for all model parameters.
-
-    For each named parameter that has a gradient, logs the L2 norm
-    as ``gradients/{name}``.  Parameters whose ``.grad`` is ``None``
-    (e.g., frozen layers) are silently skipped.
-
-    Args:
-        model: A PyTorch ``nn.Module`` whose ``.backward()`` has been called.
-        step: Optional explicit step value passed to ``openrunner.log()``.
-    """
-    for name, param in model.named_parameters():
-        if param.grad is not None:
-            norm = param.grad.norm().item()
-            openrunner.log({f"gradients/{name}": norm}, step=step, commit=False)
-
-    # Commit the step after all gradient norms have been logged.
-    openrunner.log({}, step=step, commit=True)

openrunner_sdk-0.4.0/openrunner/integration/sklearn.py

@@ -1,203 +0,0 @@
-"""Scikit-learn integration for OpenRunner.
-
-Provides utility functions to log scikit-learn model information,
-classification reports, confusion matrices, and feature importances
-to an active OpenRunner run.
-
-Usage::
-
-    from openrunner.integration.sklearn import (
-        log_model,
-        log_classification_report,
-        log_confusion_matrix,
-        log_feature_importance,
-    )
-
-    model = RandomForestClassifier().fit(X_train, y_train)
-    log_model(model)
-    log_classification_report(y_test, y_pred)
-    log_confusion_matrix(y_test, y_pred)
-    log_feature_importance(model, feature_names=["f1", "f2", "f3"])
-
-Requires: ``pip install openrunner[sklearn]``
-"""
-
-from __future__ import annotations
-
-from typing import Any, Sequence
-
-try:
-    import sklearn  # noqa: F401
-except ImportError:
-    raise ImportError(
-        "Scikit-learn integration requires scikit-learn. "
-        "Install with: pip install openrunner[sklearn]"
-    )
-
-import openrunner
-
-
-def log_model(model: Any) -> None:
-    """Log model hyperparameters via ``get_params()``.
-
-    Logs all parameters returned by the model's ``get_params()`` method
-    as a flat dict under ``model/`` prefix.
-
-    Args:
-        model: A fitted scikit-learn estimator.
-    """
-    if openrunner._active_run is None:
-        return
-
-    params = model.get_params()
-    prefixed = {f"model/{k}": v for k, v in params.items() if _is_loggable(v)}
-    if prefixed:
-        openrunner.log(prefixed)
-
-
-def log_classification_report(
-    y_true: Sequence,
-    y_pred: Sequence,
-    labels: Sequence | None = None,
-    target_names: Sequence[str] | None = None,
-) -> None:
-    """Log a classification report as a Table.
-
-    Uses ``sklearn.metrics.classification_report`` to compute precision,
-    recall, f1-score and support, then logs the result as an
-    ``openrunner.Table``.
-
-    Args:
-        y_true: Ground-truth labels.
-        y_pred: Predicted labels.
-        labels: Optional list of label indices to include.
-        target_names: Optional display names for each label.
-    """
-    if openrunner._active_run is None:
-        return
-
-    from sklearn.metrics import classification_report as _cr
-
-    report = _cr(
-        y_true,
-        y_pred,
-        labels=labels,
-        target_names=target_names,
-        output_dict=True,
-    )
-
-    columns = ["class", "precision", "recall", "f1-score", "support"]
-    data: list[list[Any]] = []
-    for cls_name, metrics in report.items():
-        if isinstance(metrics, dict):
-            data.append([
-                cls_name,
-                round(metrics.get("precision", 0), 4),
-                round(metrics.get("recall", 0), 4),
-                round(metrics.get("f1-score", 0), 4),
-                metrics.get("support", 0),
-            ])
-        else:
-            # scalar like "accuracy"
-            data.append([cls_name, metrics, None, None, None])
-
-    table = openrunner.Table(columns=columns, data=data)
-    openrunner.log({"classification_report": table})
-
-
-def log_confusion_matrix(
-    y_true: Sequence,
-    y_pred: Sequence,
-    labels: Sequence | None = None,
-    class_names: Sequence[str] | None = None,
-) -> None:
-    """Log a confusion matrix as an Image (matplotlib heatmap).
-
-    Generates a heatmap using ``matplotlib`` and logs it as an
-    ``openrunner.Image``.
-
-    Args:
-        y_true: Ground-truth labels.
-        y_pred: Predicted labels.
-        labels: Optional list of label values for ordering.
-        class_names: Optional display names for the axes.
-    """
-    if openrunner._active_run is None:
-        return
-
-    from sklearn.metrics import confusion_matrix as _cm
-
-    try:
-        import matplotlib
-        matplotlib.use("Agg")
-        import matplotlib.pyplot as plt
-    except ImportError:
-        raise ImportError(
-            "log_confusion_matrix requires matplotlib. "
-            "Install with: pip install matplotlib"
-        )
-
-    cm = _cm(y_true, y_pred, labels=labels)
-
-    fig, ax = plt.subplots(figsize=(6, 5))
-    im = ax.imshow(cm, interpolation="nearest", cmap="Blues")
-    fig.colorbar(im, ax=ax)
-
-    if class_names is not None:
-        tick_marks = list(range(len(class_names)))
-        ax.set_xticks(tick_marks)
-        ax.set_xticklabels(class_names, rotation=45, ha="right")
-        ax.set_yticks(tick_marks)
-        ax.set_yticklabels(class_names)
-
-    ax.set_xlabel("Predicted")
-    ax.set_ylabel("True")
-    ax.set_title("Confusion Matrix")
-    fig.tight_layout()
-
-    openrunner.log({"confusion_matrix": openrunner.Image(fig)})
-    plt.close(fig)
-
-
-def log_feature_importance(
-    model: Any,
-    feature_names: Sequence[str] | None = None,
-) -> None:
-    """Log feature importances as a Table.
-
-    Extracts ``feature_importances_`` from the model and logs them
-    as a sorted ``openrunner.Table`` (most important first).
-
-    Args:
-        model: A fitted scikit-learn estimator with
-            ``feature_importances_`` attribute.
-        feature_names: Optional list of feature names. If not
-            provided, uses ``feature_0``, ``feature_1``, etc.
-    """
-    if openrunner._active_run is None:
-        return
-
-    if not hasattr(model, "feature_importances_"):
-        return
-
-    importances = model.feature_importances_
-    if feature_names is None:
-        feature_names = [f"feature_{i}" for i in range(len(importances))]
-
-    # Sort by importance descending
-    pairs = sorted(
-        zip(feature_names, importances),
-        key=lambda x: x[1],
-        reverse=True,
-    )
-
-    columns = ["feature", "importance"]
-    data = [[name, round(float(imp), 6)] for name, imp in pairs]
-
-    table = openrunner.Table(columns=columns, data=data)
-    openrunner.log({"feature_importance": table})
-
-
-def _is_loggable(value: Any) -> bool:
-    """Check if a value can be logged as a metric (numeric or string)."""
-    return isinstance(value, (int, float, str, bool))