always call post processing

Author: jyu00

qiskit/providers/experiment/experiment_data.py

@@ -23,7 +23,6 @@
 import contextlib
 from collections import deque
 from datetime import datetime
-import io
 
 from qiskit.providers import Job, BaseJob, Backend, BaseBackend, Provider
 from qiskit.result import Result
@@ -34,8 +33,13 @@
 from .exceptions import ExperimentError, ExperimentEntryNotFound, ExperimentEntryExists
 from .analysis_result import AnalysisResultV1 as AnalysisResult
 from .json import NumpyEncoder, NumpyDecoder
-from .utils import (save_data, qiskit_version, plot_to_svg_bytes,
-                    ThreadSafeOrderedDict, ThreadSafeList)
+from .utils import (
+    save_data,
+    qiskit_version,
+    plot_to_svg_bytes,
+    ThreadSafeOrderedDict,
+    ThreadSafeList,
+)
 
 LOG = logging.getLogger(__name__)
 
@@ -166,12 +170,16 @@ def add_data(
         data: Union[Result, List[Result], Job, List[Job], Dict, List[Dict]],
         post_processing_callback: Optional[Callable] = None,
         **kwargs: Any,
-    ):
+    ) -> None:
         """Add experiment data.
 
         Note:
             This method is not thread safe and should not be called by the
-            `post_processing` function.
+            `post_processing_callback` function.
+
+        Note:
+            If `data` is a ``Job``, this method waits for the job to finish
+            and calls the `post_processing_callback` function asynchronously.
 
         Args:
             data: Experiment data to add.
@@ -183,18 +191,16 @@ def add_data(
                     * List[Job]: Add data from the job results.
                     * Dict: Add this data.
                     * List[Dict]: Add this list of data.
-            post_processing_callback: Callback function invoked when all pending
-                jobs finish. This ``ExperimentData`` object is the only argument
+            post_processing_callback: Callback function invoked when data is
+                added. If `data` is a ``Job``, the callback is only invoked when
+                the job finishes successfully.
+                This ``ExperimentData`` object is the only argument
                 to be passed to the callback function.
             **kwargs: Keyword arguments to be passed to the callback function.
         Raises:
             TypeError: If the input data type is invalid.
         """
-        if isinstance(data, dict):
-            self._add_single_data(data)
-        elif isinstance(data, Result):
-            self._add_result_data(data)
-        elif isinstance(data, (Job, BaseJob)):
+        if isinstance(data, (Job, BaseJob)):
             if self.backend and self.backend != data.backend():
                 LOG.warning(
                     "Adding a job from a backend (%s) that is different "
@@ -219,13 +225,22 @@ def add_data(
             )
             if self.auto_save:
                 self.save()
+            return
+
+        if isinstance(data, dict):
+            self._add_single_data(data)
+        elif isinstance(data, Result):
+            self._add_result_data(data)
         elif isinstance(data, list):
             # TODO use loop instead of recursion for fewer save()
             for dat in data:
                 self.add_data(dat)
         else:
             raise TypeError(f"Invalid data type {type(data)}.")
 
+        if post_processing_callback is not None:
+            post_processing_callback(self, **kwargs)
+
     def _wait_for_job(
         self,
         job: Union[Job, BaseJob],
@@ -364,7 +379,10 @@ def add_figures(
                 if isinstance(figure, str):
                     fig_name = figure
                 else:
-                    fig_name = f"figure_{self.experiment_id}_{datetime.now().isoformat()}"
+                    fig_name = (
+                        f"figure_{self.experiment_id[:8]}_"
+                        f"{datetime.now().isoformat()}_{len(self._figures)}"
+                    )
             else:
                 fig_name = figure_names[idx]
 
@@ -387,6 +405,7 @@ def add_figures(
             if save and service:
                 if HAS_MATPLOTLIB:
                     from matplotlib import pyplot
+
                     if isinstance(figure, pyplot.Figure):
                         figure = plot_to_svg_bytes(figure)
                 data = {
@@ -661,6 +680,7 @@ def save_all(self, service: Optional["ExperimentServiceV1"] = None) -> None:
             for name, figure in self._figures.items():
                 if HAS_MATPLOTLIB:
                     from matplotlib import pyplot
+
                     if isinstance(figure, pyplot.Figure):
                         figure = plot_to_svg_bytes(figure)
                 data = {"experiment_id": self.experiment_id, "figure": figure, "figure_name": name}

qiskit/providers/experiment/utils.py

@@ -83,7 +83,7 @@ def plot_to_svg_bytes(figure: "pyplot.Figure") -> bytes:
         Figure in bytes.
     """
     buf = io.BytesIO()
-    figure.savefig(buf, format='svg')
+    figure.savefig(buf, format="svg")
     buf.seek(0)
     figure_data = buf.read()
     buf.close()

test/python/providers/test_experimentdata.py

@@ -147,6 +147,38 @@ def _callback(_exp_data):
         exp_data.block_for_results()
         self.assertTrue(called_back)
 
+    def test_add_data_callback(self):
+        """Test add data with callback."""
+
+        def _callback(_exp_data):
+            self.assertIsInstance(_exp_data, ExperimentData)
+            nonlocal called_back_count, expected_data, subtests
+            expected_data.extend(subtests[called_back_count][1])
+            self.assertEqual([dat["counts"] for dat in _exp_data.data()], expected_data)
+            called_back_count += 1
+
+        a_result = self._get_job_result(1)
+        results = [self._get_job_result(1), self._get_job_result(1)]
+        a_dict = {"counts": {"01": 518}}
+        dicts = [{"counts": {"00": 284}}, {"counts": {"00": 14}}]
+
+        subtests = [
+            (a_result, [a_result.get_counts()]),
+            (results, [res.get_counts() for res in results]),
+            (a_dict, [a_dict["counts"]]),
+            (dicts, [dat["counts"] for dat in dicts]),
+        ]
+
+        called_back_count = 0
+        expected_data = []
+        exp_data = ExperimentData(backend=self.backend, experiment_type="qiskit_test")
+
+        for data, _ in subtests:
+            with self.subTest(data=data):
+                exp_data.add_data(data, post_processing_callback=_callback)
+
+        self.assertEqual(len(subtests), called_back_count)
+
     def test_add_data_job_callback_kwargs(self):
         """Test add job data with callback and additional arguments."""
 
@@ -206,6 +238,7 @@ def test_add_figure(self):
     def test_add_figure_plot(self):
         """Test adding a matplotlib figure."""
         import matplotlib.pyplot as plt
+
         figure, ax = plt.subplots()
         ax.plot([1, 2, 3])