mblt-vision-python 0.0.0__py3-none-any.whl

mblt_vision/benchmark/chart_utils.py

@@ -0,0 +1,146 @@
+import os
+import re
+from pathlib import Path
+from typing import Optional, Sequence
+
+import matplotlib
+
+if "MPLBACKEND" not in os.environ:
+    matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+def sanitize_text(text: str) -> str:
+    cleaned = re.sub(r"[^A-Za-z0-9._-]+", "-", text).strip("-")
+    return cleaned or "unnamed"
+
+
+def source_prefix(sources: list[Path], *, use_stem: bool) -> str:
+    parts: list[str] = []
+    for source in sources:
+        raw = (source.stem if use_stem else source.name) or str(source)
+        parts.append(sanitize_text(raw))
+    return "_".join(parts)
+
+
+def default_charts_dir(
+    script_dir: Path,
+    sources: list[Path],
+    *,
+    use_stem: bool,
+) -> Path:
+    return script_dir / "results" / "charts" / source_prefix(sources, use_stem=use_stem)
+
+
+def source_labels(sources: list[Path], *, use_stem: bool) -> list[str]:
+    labels = [
+        ((source.stem if use_stem else source.name) or str(source))
+        for source in sources
+    ]
+    counts: dict[str, int] = {}
+    for label in labels:
+        counts[label] = counts.get(label, 0) + 1
+
+    seen: dict[str, int] = {}
+    out: list[str] = []
+    for idx, label in enumerate(labels):
+        if counts[label] == 1:
+            out.append(label)
+            continue
+        seen[label] = seen.get(label, 0) + 1
+        out.append(f"{label} [{seen[label]}/{counts[label]}]")
+
+    if len(set(out)) != len(out):
+        out = [f"{label}#{idx + 1}" for idx, label in enumerate(labels)]
+    return out
+
+
+def plot_grouped_scalar_barh(
+    *,
+    models: list[str],
+    group_labels: list[str],
+    grouped_values: list[dict[str, Optional[float]]],
+    x_label: str,
+    y_label: str,
+    title: str,
+    output_path: Path,
+    fig_width: float = 14.0,
+) -> None:
+    if not models:
+        return
+
+    y = np.arange(len(models), dtype=float)
+    group_height = 0.82
+    bar_h = group_height / max(len(grouped_values), 1)
+    start = -group_height / 2 + bar_h / 2
+    fig_h = max(5.0, 0.45 * len(models) + 2.0)
+    fig, ax = plt.subplots(figsize=(fig_width, fig_h))
+    cmap = plt.get_cmap("tab10")
+
+    for idx, (label, source_values) in enumerate(zip(group_labels, grouped_values)):
+        x_vals = []
+        y_vals = []
+        for i, model in enumerate(models):
+            value = source_values.get(model)
+            if value is None:
+                continue
+            x_vals.append(float(value))
+            y_vals.append(y[i] + start + idx * bar_h)
+        if x_vals:
+            ax.barh(
+                y_vals,
+                x_vals,
+                height=bar_h * 0.95,
+                label=label,
+                color=cmap(idx % 10),
+            )
+
+    ax.set_yticks(y)
+    ax.set_yticklabels(models)
+    ax.invert_yaxis()
+    ax.set_xlabel(x_label)
+    ax.set_ylabel(y_label)
+    ax.set_title(title)
+    ax.grid(axis="x", linestyle="--", alpha=0.3)
+    handles, labels = ax.get_legend_handles_labels()
+    if handles:
+        ax.legend(loc="best")
+    plt.tight_layout()
+    fig.savefig(output_path, dpi=220)
+    plt.close(fig)
+
+
+def plot_simple_barh(
+    *,
+    labels: Sequence[str],
+    values: Sequence[float],
+    x_label: str,
+    title: str,
+    output_path: Path,
+    fig_width: float = 12.0,
+) -> None:
+    """Plots a single horizontal bar chart.
+
+    Args:
+        labels: Y-axis labels.
+        values: Numeric values aligned with labels.
+        x_label: X-axis label.
+        title: Chart title.
+        output_path: Destination PNG path.
+        fig_width: Figure width.
+    """
+    if not labels:
+        return
+    fig, ax = plt.subplots(figsize=(fig_width, max(4.0, 0.45 * len(labels) + 2.0)))
+    y = list(range(len(labels)))
+    ax.barh(y, [float(value) for value in values])
+    ax.set_yticks(y)
+    ax.set_yticklabels(list(labels))
+    ax.invert_yaxis()
+    ax.set_xlabel(x_label)
+    ax.set_title(title)
+    ax.grid(axis="x", linestyle="--", alpha=0.3)
+    plt.tight_layout()
+    fig.savefig(output_path, dpi=220)
+    plt.close(fig)

mblt_vision/benchmark/io_utils.py

@@ -0,0 +1,64 @@
+"""Shared file I/O helpers for benchmark scripts."""
+
+from __future__ import annotations
+
+import csv
+import json
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+
+JsonObject = dict[str, Any]
+CsvRow = dict[str, Any]
+
+
+def safe_filename(text: str, *, replace_slash_only: bool = False) -> str:
+    """Returns a filename-safe representation of text.
+
+    Args:
+        text: Source text to convert.
+        replace_slash_only: Whether to preserve the legacy behavior of replacing only forward slashes.
+
+    Returns:
+        Sanitized text suitable for benchmark output filenames.
+    """
+    if replace_slash_only:
+        return text.replace("/", "__")
+
+    cleaned = (
+        text.replace("/", "__").replace("\\", "__").replace(":", "_").replace(" ", "_")
+    )
+    return cleaned or "unnamed"
+
+
+def write_json(path: Path, payload: Any) -> None:
+    """Writes an indented UTF-8 JSON file after creating its parent directory.
+
+    Args:
+        path: Destination path.
+        payload: JSON-serializable payload.
+    """
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as f:
+        json.dump(payload, f, ensure_ascii=False, indent=2)
+
+
+def write_csv(path: Path, rows: Sequence[Mapping[str, Any]]) -> None:
+    """Writes dictionaries to CSV using the union of row keys as the field order.
+
+    Args:
+        path: Destination path.
+        rows: Row mappings to write. Empty rows are ignored to preserve existing script behavior.
+    """
+    if not rows:
+        return
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fieldnames = list(rows[0].keys())
+    for row in rows[1:]:
+        for key in row:
+            if key not in fieldnames:
+                fieldnames.append(key)
+    with path.open("w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        for row in rows:
+            writer.writerow({key: row.get(key, "") for key in fieldnames})