🐛 Preserve successful programs after status errors

Keep each indexed outcome independent when a later sibling's status query fails.
Remove obsolete batch-format guidance now that program lists own submission.

Assisted-by: GPT-6 via Codex

Author: burgholzer

docs/qir/index.md

@@ -350,7 +350,3 @@ records are suppressed, and unsupported operations produce a failed QDMI job.
 Both profiles preserve global phase and logical wire order, including SWAPs.
 LLVM target triples must match the host architecture and operating system
 because the JIT executes in process.
-
-The generic submission APIs reject the QDMI batch-job format. Batch jobs contain
-job handles rather than serialized program bytes and require a separate typed
-API.

python/mqt/core/plugins/qdmi_batch.py

@@ -197,30 +197,40 @@ def _refresh(self, indices: Sequence[int], *, wait: bool = False) -> Iterator[li
                 groups.setdefault(id(handle), []).append(index)
         for group in groups.values():
             pending = [i for i in group if self._entries[i].attempts[-1].status not in _TERMINAL]
-            if pending:
-                handle = self._entries[pending[0]].attempts[-1].handle
-                assert handle is not None
-                stage = "wait" if wait else "status"
-                try:  # ruff:ignore[too-many-statements-in-try-clause] Keep shared query failures on every affected entry.
-                    if wait and not handle.wait():
-                        msg = "Timed out waiting for the QDMI job."
-                        raise TimeoutError(msg)  # ruff:ignore[raise-within-try] Record timeouts with other wait failures.
-                    stage = "status"
-                    aggregate = handle.check()
-                    # Resolve individual outcomes before attributing an aggregate failure.
-                    for index in pending:
-                        attempt = self._entries[index].attempts[-1]
+            if not pending:
+                yield group
+                continue
+            handle = self._entries[pending[0]].attempts[-1].handle
+            assert handle is not None
+            stage = "wait" if wait else "status"
+            try:
+                if wait and not handle.wait():
+                    msg = "Timed out waiting for the QDMI job."
+                    raise TimeoutError(msg)  # ruff:ignore[raise-within-try] Record timeouts with other wait failures.
+                stage = "status"
+                aggregate = handle.check()
+            except BaseException as exc:
+                for index in pending:
+                    attempt = self._entries[index].attempts[-1]
+                    self._set_attempt(index, replace(attempt, status=None))
+                    self.record_failure(index, stage, exc)
+                if not isinstance(exc, Exception):
+                    raise
+            else:
+                # Resolve individual outcomes before attributing an aggregate failure.
+                for index in pending:
+                    attempt = self._entries[index].attempts[-1]
+                    try:
                         status = aggregate
                         if aggregate in {Job.Status.FAILED, Job.Status.CANCELED}:
                             status = handle.get_program_status(attempt.program_index) or aggregate
-                        self._set_attempt(index, replace(attempt, status=status))
-                except BaseException as exc:
-                    for index in pending:
-                        attempt = self._entries[index].attempts[-1]
+                    except BaseException as exc:
                         self._set_attempt(index, replace(attempt, status=None))
-                        self.record_failure(index, stage, exc)
-                    if not isinstance(exc, Exception):
-                        raise
+                        self.record_failure(index, "status", exc)
+                        if not isinstance(exc, Exception):
+                            raise
+                    else:
+                        self._set_attempt(index, replace(attempt, status=status))
             yield group
 
     def statuses(self) -> tuple[Job.Status | None, ...]:

test/python/plugins/test_qdmi_batch.py

@@ -381,6 +381,31 @@ def test_native_read_failure_never_replaces_execution(stage: str) -> None:
     assert fixture.native_calls == [[0, 1, 2]]
 
 
+def test_later_native_status_read_failure_keeps_confirmed_siblings() -> None:
+    """A failed status download cannot erase earlier or later successful programs."""
+    fixture = BatchFixture(native=True)
+    fixture.batch.submit()
+    shared = fixture.jobs[0]
+    shared.check.return_value = Job.Status.FAILED
+    cause = RuntimeError("status unavailable")
+    shared.get_program_status.side_effect = [Job.Status.DONE, cause, Job.Status.DONE, Job.Status.DONE]
+
+    with pytest.raises(RuntimeError, match="status unavailable") as caught:
+        fixture.batch.complete()
+    assert caught.value.__cause__ is cause
+    assert [entry.result for entry in fixture.batch.entries] == ["0", None, "2"]
+    assert [entry.attempts[-1].status for entry in fixture.batch.entries] == [
+        Job.Status.DONE,
+        None,
+        Job.Status.DONE,
+    ]
+    assert fixture.submitted == [0, 1, 2]
+
+    fixture.batch.complete()
+    assert [entry.result for entry in fixture.batch.entries] == ["0", "1", "2"]
+    assert fixture.submitted == [0, 1, 2]
+
+
 def test_uncertain_native_admission_has_no_single_fallback() -> None:
     """A native submission error marks all selected programs uncertain without replay."""
     fixture = BatchFixture(native=True)