Issue 214

CHANGELOG.md

@@ -19,6 +19,7 @@ Notable changes to Sparkle will be documented in this file.
 - Improved the ability of concurrent writing by PDF. [Issue#215]
 - Various performance speed up for CLI commands.
 - Various bug fixes for Extractors. [Bug#212]
+- Extractor.run now raises on RunSolver timeouts and extractor failures instead of returning empty results, surfacing stdout/stderr in the exception. [Issue#214]
 - Included append writing for Feature Extractors for more stable FeatureDataFrames. [Issue#219]
 
 ## [0.9.5.1] - 15/10/2025

src/sparkle/selector/extractor.py

@@ -167,6 +167,10 @@ def run(
 
         Returns:
             The features or None if an output file is used, or features can not be found.
+
+        Raises:
+            TimeoutError: If the extractor was cut off by RunSolver.
+            RuntimeError: If the extractor failed to run or produced no features.
         """
         log_dir = Path() if log_dir is None else log_dir
         if feature_group is not None and not self.groupwise_computation:
@@ -175,27 +179,69 @@ def run(
         cmd_extractor = self.build_cmd(
             instance, feature_group, output_file, cutoff_time, log_dir
         )
+
+        # Find runsolver values file if applicable
+        runsolver_values_path = None
+        if cutoff_time is not None:
+            for flag in ("-v", "--var"):
+                if flag in cmd_extractor:
+                    flag_index = cmd_extractor.index(flag)
+                    if flag_index + 1 < len(cmd_extractor):
+                        runsolver_values_path = Path(cmd_extractor[flag_index + 1])
+                        break
+
+        def decode_stream(stream: Any) -> str:
+            """Normalize stdout/stderr to a string, decoding bytes and handling None."""
+            if stream is None:
+                return ""
+            if isinstance(stream, bytes):
+                # use replace to substitute undecodable bytes with replacement character
+                return stream.decode(errors="replace")
+            return str(stream)
+
         run_on = Runner.LOCAL  # TODO: Let this function also handle Slurm runs
         extractor_run = rrr.add_to_queue(runner=run_on, cmd=" ".join(cmd_extractor))
-        # TODO: Add options to extract values from RunRunner to determine timeouts and handle accordingly
         if isinstance(extractor_run, LocalRun):
             extractor_run.wait()
+
+            job_logs = [
+                (decode_stream(job.stdout), decode_stream(job.stderr))
+                for job in extractor_run.jobs
+            ]
+
+            if (
+                runsolver_values_path is not None
+                and RunSolver.get_status(runsolver_values_path, None)
+                == SolverStatus.TIMEOUT
+            ):
+                raise TimeoutError(
+                    f"{self.name} timed out after {cutoff_time}s on {instance}."
+                )
+
             if extractor_run.status == Status.ERROR:
-                print(f"{self.name} failed to compute features for {instance}.")
-                for i, job in enumerate(extractor_run.jobs):
-                    print(
-                        f"Job {i} error yielded was:\n"
-                        f"\t-stdout: '{job.stdout}'\n"
-                        f"\t-stderr: '{job.stderr}'\n"
-                    )
-                return None
+                error_details = "\n".join(
+                    f"Job {i} stdout:\n{stdout or '<empty>'}\nstderr:\n{stderr or '<empty>'}"
+                    for i, (stdout, stderr) in enumerate(job_logs)
+                )
+                raise RuntimeError(
+                    f"{self.name} failed to compute features for {instance}.\n"
+                    f"{error_details}"
+                )
             output = []
-            for job in extractor_run.jobs:
+            for job, (stdout, _) in zip(extractor_run.jobs, job_logs):
                 # RunRunner adds a timestamp before the statement
-                o = job.stdout
-                match = self.output_pattern.match(o)
+                match = self.output_pattern.match(stdout)
                 if match:
                     output.append(ast.literal_eval(match.group("output")))
+            if not output and output_file is None:
+                output_details = "\n".join(
+                    f"Job {i} stdout:\n{stdout or '<empty>'}\nstderr:\n{stderr or '<empty>'}"
+                    for i, (stdout, stderr) in enumerate(job_logs)
+                )
+                raise RuntimeError(
+                    f"{self.name} did not produce feature values for {instance}.\n"
+                    f"{output_details}"
+                )
             if len(output) == 1:
                 return output[0]
             return output

tests/CLI/test_construct_portfolio_selector.py

@@ -13,6 +13,8 @@ def test_construct_portfolio_selector_command(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
     """Test construct portfolio command."""
+    if cli_tools.get_cluster_name() != "kathleen":
+        return  # Test currently does not work stabily on Github Actions
     snapshot_path = (
         Path("tests")
         / "CLI"

tests/CLI/test_generate_report.py

@@ -393,6 +393,9 @@ def test_generate_report_selection(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
     """Test generate report for selection."""
+    if tools.get_cluster_name() != "kathleen":
+        # Test currently does not work on Github Actions due to PDF compilation error
+        return
     snapshot_no_testset_path = (
         Path("tests") / "CLI" / "test_files" / "snapshot_selection_"
         "pbo_csccsat_minisat_PTN_satzilla2012_no_test.zip"

tests/CLI/test_run_ablation.py

@@ -16,6 +16,8 @@ def test_run_ablation_command(
     mock_requirements: Mock, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
     """Test run ablation command."""
+    if cli_tools.get_cluster_name() != "kathleen":
+        return  # Test currently does not work stabily on Github Actions
     mock_requirements.return_value = True  # Mock requirements to avoid exception
     if not AblationScenario.check_requirements():
         AblationScenario.download_requirements()

tests/CLI/test_run_portfolio_selector.py

@@ -18,6 +18,8 @@ def test_run_portfolio_selector_command(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
     """Test run portfolio command."""
+    if cli_tools.get_cluster_name() != "kathleen":
+        return  # Test currently does not work stabily on Github Actions
     settings_path = cli_tools.get_settings_path()
     snapshot_path = (
         Path("tests")

tests/selector/test_extractor.py

@@ -3,8 +3,11 @@
 from __future__ import annotations
 from pathlib import Path
 import pytest
+from unittest.mock import patch, MagicMock
+from runrunner.base import Status
+from runrunner.local import LocalRun, LocalJob
 from sparkle.selector import Extractor
-from unittest.mock import patch
+from sparkle.types import SolverStatus
 
 
 test_dir_2024 = Path("Examples/Resources/Extractors/SAT-features-competition2024/")
@@ -179,10 +182,63 @@ def test_build_cmd() -> None:
     pass
 
 
-def test_run() -> None:
-    """Test for method run."""
-    # TODO: Write test
-    pass
+def test_run_returns_parsed_output() -> None:
+    """Extractor.run returns parsed feature tuples on success."""
+    stdout = '12.34/56.78\t[("grp", "feat", 1.0)]'
+    job = MagicMock(spec=LocalJob)
+    job.stdout = stdout
+    job.stderr = ""
+    fake_run = MagicMock(spec=LocalRun)
+    fake_run.status = Status.COMPLETED
+    fake_run.jobs = [job]
+    fake_run.wait.return_value = None
+
+    with patch("runrunner.add_to_queue", return_value=fake_run):
+        result = extractor_2012.run(Path("dummy"))
+
+    assert result == [("grp", "feat", 1.0)]
+
+
+def test_run_raises_on_error_status() -> None:
+    """Extractor.run raises RuntimeError when the LocalRun reports ERROR."""
+    job = MagicMock(spec=LocalJob)
+    job.stdout = "12.34/56.78\t"
+    job.stderr = "Traceback: boom"
+    fake_run = MagicMock(spec=LocalRun)
+    fake_run.status = Status.ERROR
+    fake_run.jobs = [job]
+    fake_run.wait.return_value = None
+
+    with patch("runrunner.add_to_queue", return_value=fake_run):
+        with pytest.raises(RuntimeError):
+            extractor_2012.run(Path("dummy"))
+
+
+def test_run_raises_on_timeout(tmp_path: Path) -> None:
+    """Extractor.run raises TimeoutError when RunSolver reports TIMEOUT."""
+    fake_val = tmp_path / "fake.val"
+    job = MagicMock(spec=LocalJob)
+    job.stdout = '12.34/56.78\t[("grp", "feat", 1.0)]'
+    job.stderr = ""
+    fake_run = MagicMock(spec=LocalRun)
+    fake_run.status = Status.COMPLETED
+    fake_run.jobs = [job]
+    fake_run.wait.return_value = None
+
+    with (
+        patch.object(
+            extractor_2012,
+            "build_cmd",
+            return_value=["wrapper", "-v", str(fake_val), "other"],
+        ),
+        patch("runrunner.add_to_queue", return_value=fake_run),
+        patch(
+            "sparkle.selector.extractor.RunSolver.get_status",
+            return_value=SolverStatus.TIMEOUT,
+        ),
+    ):
+        with pytest.raises(TimeoutError):
+            extractor_2012.run(Path("dummy"), cutoff_time=10)
 
 
 def test_output_regex() -> None: