differential-coverage 1.0.2__tar.gz → 1.0.4__tar.gz

{differential_coverage-1.0.2 → differential_coverage-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: differential_coverage
-Version: 1.0.2
+Version: 1.0.4
 Summary: Compute differential coverage, a better way of comparing testing tools.
 Author-email: Valentin Huber <contact@valentinhuber.me>
 License-Expression: MIT

{differential_coverage-1.0.2 → differential_coverage-1.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "differential_coverage"
-version = "1.0.2"
+version = "1.0.4"
 description = "Compute differential coverage, a better way of comparing testing tools."
 readme = "README.md"
 license = "MIT"

{differential_coverage-1.0.2 → differential_coverage-1.0.4}/src/differential_coverage/fs.py

@@ -37,7 +37,11 @@ def read_campaign_dir(
     campaigns: dict[str, dict[str, set[str]]] = {}
     for approach_dir in path.iterdir():
         if approach_dir.is_dir():
-            campaigns[approach_dir.name] = read_approach_dir(approach_dir)
+            approach_data = read_approach_dir(approach_dir)
+            if len(approach_data) == 0:
+                print(f"Warning: No coverage data in {approach_dir}. Skipping.")
+                continue
+            campaigns[approach_dir.name] = approach_data
         else:
             raise ValueError(f"Invalid file: {approach_dir}")
     return campaigns

{differential_coverage-1.0.2 → differential_coverage-1.0.4}/src/differential_coverage/output.py

@@ -3,8 +3,7 @@
 from __future__ import annotations
 
 import csv
-import sys
-from collections.abc import Mapping, Sequence
+from collections.abc import Callable, Mapping, Sequence
 from typing import Literal, Optional
 
 
@@ -13,26 +12,46 @@ from differential_coverage.types import ApproachId
 OutputFormat = Literal["stdout", "csv", "latex"]
 
 
+class _PrinterIO:
+    """Minimal file-like wrapper that forwards writes to a printer function."""
+
+    def __init__(self, printer: Callable[[str], None]) -> None:
+        self._printer = printer
+
+    def write(self, s: str) -> int:  # pragma: no cover - trivial adapter
+        # csv.writer may call write multiple times per row; strip trailing newlines
+        # and avoid printing empty chunks.
+        if not s:
+            return 0
+        if s.endswith("\n"):
+            s = s[:-1]
+        if s:
+            self._printer(s)
+        return len(s)
+
+
 def print_scores(
     scores: Mapping[ApproachId, float],
     *,
     output: OutputFormat = "stdout",
     colormap: str = "viridis",
     latex_enable_color: bool = False,
+    printer: Callable[[str], None] = print,
 ) -> None:
     """Print one score per approach, in the requested output format."""
     name_sorted = sorted(scores.items(), key=lambda x: x[0])
     performance_sorted = sorted(name_sorted, key=lambda x: x[1], reverse=True)
 
     if output == "stdout":
-        _print_scores_plain(performance_sorted)
+        _print_scores_plain(performance_sorted, printer=printer)
     elif output == "csv":
-        _print_scores_csv(performance_sorted)
+        _print_scores_csv(performance_sorted, printer=printer)
     elif output == "latex":
         _print_scores_latex(
             performance_sorted,
             enable_color=latex_enable_color,
             colormap=colormap,
+            printer=printer,
         )
     else:
         raise ValueError(f"Invalid output format: {output}")
@@ -40,15 +59,19 @@ def print_scores(
 
 def _print_scores_plain(
     performance_sorted: Sequence[tuple[ApproachId, float]],
+    *,
+    printer: Callable[[str], None],
 ) -> None:
     for approach, score in performance_sorted:
-        print(f"{approach}: {score:.2f}")
+        printer(f"{approach}: {score:.2f}")
 
 
 def _print_scores_csv(
     performance_sorted: Sequence[tuple[ApproachId, float]],
+    *,
+    printer: Callable[[str], None],
 ) -> None:
-    writer = csv.writer(sys.stdout)
+    writer = csv.writer(_PrinterIO(printer))
     writer.writerow(("approach", "score"))
     for approach, score in performance_sorted:
         writer.writerow((approach, f"{score:.2f}"))
@@ -73,14 +96,15 @@ def _print_scores_latex(
     *,
     enable_color: bool = False,
     colormap: str = "viridis",
+    printer: Callable[[str], None],
 ) -> None:
     """LaTeX table (optionally with score cells colored by value)."""
-    print(r"\begin{tabular}{lr}")
-    print(r"approach & score \\")
+    printer(r"\begin{tabular}{lr}")
+    printer(r"approach & score \\")
     if not performance_sorted:
-        print(r"\end{tabular}")
+        printer(r"\end{tabular}")
         return
-    print(r"\hline")
+    printer(r"\hline")
     min_v, max_v = (0.0, 0.0)
     if enable_color:
         values = [s for _, s in performance_sorted]
@@ -89,10 +113,10 @@ def _print_scores_latex(
         if enable_color:
             n = _norm_value(score, min_v, max_v)
             hex_color = _colormap_light_hex(n, colormap=colormap)
-            print(rf"{approach} & \cellcolor[HTML]{{{hex_color}}}{{{score:.2f}}} \\")
+            printer(rf"{approach} & \cellcolor[HTML]{{{hex_color}}}{{{score:.2f}}} \\")
         else:
-            print(f"{approach} & {score:.2f} \\\\")
-    print(r"\end{tabular}")
+            printer(f"{approach} & {score:.2f} \\\\")
+    printer(r"\end{tabular}")
 
 
 def print_relcov_corpus_table(
@@ -103,16 +127,25 @@ def print_relcov_corpus_table(
     colormap: str = "viridis",
     latex_rotate_headers: Optional[float] = None,
     latex_enable_color: bool = False,
+    printer: Callable[[str], None] = print,
 ) -> None:
     """Print a table of relcov performance: rows = approaches, columns = corpus approaches."""
     if not corpus_approaches:
-        print("No corpus approaches (single-trial subdirs) found.")
+        printer("No corpus approaches (single-trial subdirs) found.")
         return
 
     if output == "stdout":
-        _print_relcov_corpus_table_plain(corpus_approaches, table)
+        _print_relcov_corpus_table_plain(
+            corpus_approaches,
+            table,
+            printer=printer,
+        )
     elif output == "csv":
-        _print_relcov_corpus_table_csv(corpus_approaches, table)
+        _print_relcov_corpus_table_csv(
+            corpus_approaches,
+            table,
+            printer=printer,
+        )
     elif output == "latex":
         _print_relcov_corpus_table_latex(
             corpus_approaches,
@@ -120,6 +153,7 @@ def print_relcov_corpus_table(
             rotate_headers=latex_rotate_headers,
             enable_color=latex_enable_color,
             colormap=colormap,
+            printer=printer,
         )
     else:
         raise ValueError(f"Invalid output format: {output}")
@@ -128,6 +162,8 @@ def print_relcov_corpus_table(
 def _print_relcov_corpus_table_plain(
     corpus_approaches: Sequence[ApproachId],
     table: Mapping[ApproachId, Mapping[ApproachId, float]],
+    *,
+    printer: Callable[[str], None],
 ) -> None:
     row_labels = sorted(table.keys())
     col_labels = sorted(corpus_approaches)
@@ -139,7 +175,7 @@ def _print_relcov_corpus_table_plain(
     header = "approach".ljust(col_width)
     for c in col_labels:
         header += str(c).rjust(num_width)
-    print(header)
+    printer(header)
     for row in row_labels:
         line = str(row).ljust(col_width)
         for c in col_labels:
@@ -148,16 +184,18 @@ def _print_relcov_corpus_table_plain(
                 line += f"{val:>{num_width}.5f}"
             else:
                 line += " " * num_width
-        print(line)
+        printer(line)
 
 
 def _print_relcov_corpus_table_csv(
     corpus_approaches: Sequence[ApproachId],
     table: Mapping[ApproachId, Mapping[ApproachId, float]],
+    *,
+    printer: Callable[[str], None],
 ) -> None:
     row_labels = sorted(table.keys())
     col_labels = sorted(corpus_approaches)
-    writer = csv.writer(sys.stdout)
+    writer = csv.writer(_PrinterIO(printer))
     writer.writerow(["approach"] + list(col_labels))
     for row in row_labels:
         cells: list[str] = [str(row)]
@@ -167,7 +205,11 @@ def _print_relcov_corpus_table_csv(
         writer.writerow(cells)
 
 
-def _latex_print_rotcol_command(*, angle: Optional[float] = None) -> None:
+def _latex_print_rotcol_command(
+    *,
+    angle: Optional[float] = None,
+    printer: Callable[[str], None],
+) -> None:
     """Emit the \\rotcol LaTeX command definition.
     Requires \\usepackage{graphicx} and \\usepackage{calc}.
     Rotated text is raised so it stays in the header row; row height is \\widthof{#1}.
@@ -177,7 +219,7 @@ def _latex_print_rotcol_command(*, angle: Optional[float] = None) -> None:
 
     # Raise rotated text by half its width so it doesn't extend below the baseline
     # into the first data row; then reserve full width as row height.
-    print(
+    printer(
         r"""\newcolumntype{R}[2]{%
     >{\adjustbox{angle=#1,lap=\width-(#2)}\bgroup}%
     l%
@@ -213,6 +255,7 @@ def _print_relcov_corpus_table_latex(
     rotate_headers: Optional[float] = None,
     enable_color: bool = False,
     colormap: str = "viridis",
+    printer: Callable[[str], None],
 ) -> None:
     try:
         from pylatex.utils import escape_latex  # type: ignore[import-untyped] # does not provide types
@@ -229,13 +272,13 @@ def _print_relcov_corpus_table_latex(
 
     num_cols = 1 + len(col_labels)
     align_spec = "l" + "r" * (num_cols - 1)
-    _latex_print_rotcol_command(angle=rotate_headers)
-    print(r"\begin{tabular}{" + align_spec + r"}")
+    _latex_print_rotcol_command(angle=rotate_headers, printer=printer)
+    printer(r"\begin{tabular}{" + align_spec + r"}")
     header_cells = [""] + [
         _latex_rotcol(escape_latex(str(c)), angle=rotate_headers) for c in col_labels
     ]
-    print(" & ".join(header_cells) + r" \\")
-    print(r"\hline")
+    printer("\t" + " & ".join(header_cells) + r" \\")
+    printer(r"\hline")
     for row in row_labels:
         cells: list[str] = [escape_latex(str(row))]
         for c in col_labels:
@@ -248,8 +291,8 @@ def _print_relcov_corpus_table_latex(
                 cells.append(rf"\cellcolor[HTML]{{{hex_color}}}{{{val:.3f}}}")
             else:
                 cells.append(f"{val:.3f}")
-        print(" & ".join(cells) + r" \\")
-    print(r"\end{tabular}")
+        printer("\t" + " & ".join(cells) + r" \\")
+    printer(r"\end{tabular}")
 
 
 def _colormap_light_hex(t: float, *, colormap: str = "viridis") -> str:

{differential_coverage-1.0.2 → differential_coverage-1.0.4}/src/differential_coverage.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: differential_coverage
-Version: 1.0.2
+Version: 1.0.4
 Summary: Compute differential coverage, a better way of comparing testing tools.
 Author-email: Valentin Huber <contact@valentinhuber.me>
 License-Expression: MIT

differential_coverage-1.0.4/tests/test_output.py

@@ -0,0 +1,99 @@
+"""Unit tests for differential_coverage output helpers."""
+
+import csv
+import io
+from typing import Callable
+
+from differential_coverage.output import print_relcov_corpus_table, print_scores
+
+# Deliberately unsorted order for both corpus (columns) and table (rows)
+_UNSORTED_CORPUS = ["z_approach", "a_approach", "m_approach"]
+_UNSORTED_TABLE = {
+    "z_approach": {"z_approach": 1.0, "a_approach": 0.2, "m_approach": 0.3},
+    "a_approach": {"z_approach": 0.1, "a_approach": 1.0, "m_approach": 0.4},
+    "m_approach": {"z_approach": 0.5, "a_approach": 0.6, "m_approach": 1.0},
+}
+_EXPECTED_ROWS = ["a_approach", "m_approach", "z_approach"]
+_EXPECTED_COLS = ["a_approach", "m_approach", "z_approach"]
+
+
+def _capture_printer() -> tuple[list[str], Callable[[str], None]]:
+    lines: list[str] = []
+
+    def printer(s: str) -> None:
+        lines.append(s)
+
+    return lines, printer
+
+
+def test_relcov_table_sorted_stdout() -> None:
+    """Relcov table stdout output has rows and columns sorted alphabetically."""
+    captured, printer = _capture_printer()
+    print_relcov_corpus_table(
+        _UNSORTED_CORPUS,
+        _UNSORTED_TABLE,
+        output="stdout",
+        printer=printer,
+    )
+
+    lines = [s.strip() for s in "\n".join(captured).strip().splitlines()]
+    header = lines[0]
+    assert header.startswith("approach")
+    row_labels = [line.split()[0] for line in lines[1:]]
+    assert row_labels == _EXPECTED_ROWS
+    pos = 0
+    for col in _EXPECTED_COLS:
+        idx = header.find(col, pos)
+        assert idx >= 0, f"column {col!r} not found in header"
+        pos = idx + len(col)
+
+
+def test_relcov_table_sorted_csv() -> None:
+    """Relcov table CSV output has rows and columns sorted alphabetically."""
+    captured, printer = _capture_printer()
+    print_relcov_corpus_table(
+        _UNSORTED_CORPUS,
+        _UNSORTED_TABLE,
+        output="csv",
+        printer=printer,
+    )
+
+    csv_text = "\n".join(captured)
+    reader = csv.reader(io.StringIO(csv_text))
+    rows = list(reader)
+    assert rows[0][0] == "approach"
+    assert rows[0][1:] == _EXPECTED_COLS
+    assert [r[0] for r in rows[1:]] == _EXPECTED_ROWS
+
+
+def test_print_scores_uses_printer_stdout() -> None:
+    """print_scores writes human-readable scores via the provided printer."""
+    scores = {"b": 0.1, "a": 1.0}
+    captured, printer = _capture_printer()
+
+    print_scores(scores, output="stdout", printer=printer)
+
+    # Scores should be sorted by value descending, then by name
+    joined = "\n".join(captured)
+    assert "a: 1.00" in joined
+    assert "b: 0.10" in joined
+    # Ensure our custom printer was used (no direct writes to sys.stdout here)
+    assert joined.count("\n") >= 0
+
+
+def test_print_scores_uses_printer_csv() -> None:
+    """print_scores CSV output is routed through the provided printer."""
+    scores = {"b": 0.1, "a": 1.0}
+    captured, printer = _capture_printer()
+
+    print_scores(scores, output="csv", printer=printer)
+
+    csv_text = "\n".join(captured)
+    reader = csv.reader(io.StringIO(csv_text))
+    rows = list(reader)
+
+    # Header + two data rows
+    assert rows[0] == ["approach", "score"]
+    # Order should be by score descending
+    assert rows[1][0] == "a"
+    assert rows[2][0] == "b"

differential_coverage-1.0.2/tests/test_output.py

@@ -1,64 +0,0 @@
-"""Unit tests for differential_coverage output helpers."""
-
-import csv
-import io
-import sys
-
-from differential_coverage.output import print_relcov_corpus_table
-
-# Deliberately unsorted order for both corpus (columns) and table (rows)
-_UNSORTED_CORPUS = ["z_approach", "a_approach", "m_approach"]
-_UNSORTED_TABLE = {
-    "z_approach": {"z_approach": 1.0, "a_approach": 0.2, "m_approach": 0.3},
-    "a_approach": {"z_approach": 0.1, "a_approach": 1.0, "m_approach": 0.4},
-    "m_approach": {"z_approach": 0.5, "a_approach": 0.6, "m_approach": 1.0},
-}
-_EXPECTED_ROWS = ["a_approach", "m_approach", "z_approach"]
-_EXPECTED_COLS = ["a_approach", "m_approach", "z_approach"]
-
-
-def test_relcov_table_sorted_stdout() -> None:
-    """Relcov table stdout output has rows and columns sorted alphabetically."""
-    out = io.StringIO()
-    old_stdout = sys.stdout
-    try:
-        sys.stdout = out
-        print_relcov_corpus_table(
-            _UNSORTED_CORPUS,
-            _UNSORTED_TABLE,
-            output="stdout",
-        )
-    finally:
-        sys.stdout = old_stdout
-
-    lines = [s.strip() for s in out.getvalue().strip().splitlines()]
-    header = lines[0]
-    assert header.startswith("approach")
-    row_labels = [line.split()[0] for line in lines[1:]]
-    assert row_labels == _EXPECTED_ROWS
-    pos = 0
-    for col in _EXPECTED_COLS:
-        idx = header.find(col, pos)
-        assert idx >= 0, f"column {col!r} not found in header"
-        pos = idx + len(col)
-
-
-def test_relcov_table_sorted_csv() -> None:
-    """Relcov table CSV output has rows and columns sorted alphabetically."""
-    out = io.StringIO()
-    old_stdout = sys.stdout
-    try:
-        sys.stdout = out
-        print_relcov_corpus_table(
-            _UNSORTED_CORPUS,
-            _UNSORTED_TABLE,
-            output="csv",
-        )
-    finally:
-        sys.stdout = old_stdout
-
-    reader = csv.reader(io.StringIO(out.getvalue()))
-    rows = list(reader)
-    assert rows[0][0] == "approach"
-    assert rows[0][1:] == _EXPECTED_COLS
-    assert [r[0] for r in rows[1:]] == _EXPECTED_ROWS