Merge branch 'main' into deepcopy_bug

pyproject.toml

@@ -4,4 +4,4 @@ build-backend = "setuptools.build_meta"
 
 [tool.black]
 line-length = 100
-target-version = ['py38', 'py39', 'py310', 'py311']
+target-versions = ['py38', 'py39', 'py310', 'py311']

test/ibm_test_case.py

@@ -23,7 +23,7 @@
 
 from qiskit.test.reference_circuits import ReferenceCircuits
 from qiskit_ibm_runtime import QISKIT_IBM_RUNTIME_LOGGER_NAME
-from qiskit_ibm_runtime import QiskitRuntimeService
+from qiskit_ibm_runtime import QiskitRuntimeService, Sampler, Options
 
 from .utils import setup_test_logging
 from .decorators import IntegrationTestDependencies, integration_test_setup
@@ -135,7 +135,7 @@ def setUpClass(cls):
         cls.program_ids = {}
         cls.sim_backends = {}
         service = cls.service
-        cls.program_ids[service.channel] = "circuit-runner"
+        cls.program_ids[service.channel] = "sampler"
         cls._find_sim_backends()
 
     @classmethod
@@ -196,14 +196,26 @@ def _run_program(
             "job_tags": job_tags,
             "max_execution_time": max_execution_time,
         }
-        job = service.run(
-            program_id=pid,
-            inputs=inputs,
-            options=options,
-            session_id=session_id,
-            callback=callback,
-            start_session=start_session,
-        )
+        if pid == "sampler":
+            backend = service.get_backend(backend_name)
+            options = Options()
+            if log_level:
+                options.environment.log_level = log_level
+            if job_tags:
+                options.environment.job_tags = job_tags
+            if max_execution_time:
+                options.max_execution_time = max_execution_time
+            sampler = Sampler(backend=backend, options=options)
+            job = sampler.run(ReferenceCircuits.bell(), callback=callback)
+        else:
+            job = service.run(
+                program_id=pid,
+                inputs=inputs,
+                options=options,
+                session_id=session_id,
+                callback=callback,
+                start_session=start_session,
+            )
         self.log.info("Runtime job %s submitted.", job.job_id())
         self.to_cancel[service.channel].append(job)
         return job

test/integration/test_job.py

@@ -22,7 +22,6 @@
 
 from qiskit_ibm_runtime.constants import API_TO_JOB_ERROR_MESSAGE
 from qiskit_ibm_runtime.exceptions import (
-    IBMRuntimeError,
     RuntimeJobFailureError,
     RuntimeInvalidStateError,
     RuntimeJobNotFound,
@@ -137,7 +136,7 @@ def test_run_program_override_max_execution_time(self, service):
     @run_integration_test
     def test_invalid_max_execution_time_fails(self, service):
         """Test that program fails when max_execution_time is less than 300."""
-        with self.assertRaises(IBMRuntimeError):
+        with self.assertRaises(ValueError):
             self._run_program(service, max_execution_time=299)
 
     @run_integration_test
@@ -157,8 +156,7 @@ def test_cancel_job_queued(self, service):
     @run_integration_test
     def test_cancel_job_running(self, service):
         """Test canceling a running job."""
-        job = self._run_program(service, iterations=3)
-        wait_for_status(job, JobStatus.RUNNING)
+        job = self._run_program(service, iterations=5)
         if not cancel_job_safe(job, self.log):
             return
         time.sleep(10)  # Wait a bit for DB to update.
@@ -197,7 +195,7 @@ def test_delete_job_queued(self, service):
         with self.assertRaises(RuntimeJobNotFound):
             service.job(job.job_id())
 
-    @unittest.skip("Final result only supported in custom programs.")
+    @unittest.skip("skip until qiskit-ibm-runtime #933 is fixed")
     @run_integration_test
     def test_final_result(self, service):
         """Test getting final result."""
@@ -217,6 +215,7 @@ def test_job_status(self, service):
         self.assertTrue(job.status())
 
     @run_integration_test
+    @quantum_only
     def test_job_inputs(self, service):
         """Test job inputs."""
         interim_results = get_complex_types()
@@ -225,7 +224,7 @@ def test_job_inputs(self, service):
             "interim_results": interim_results,
             "circuits": ReferenceCircuits.bell(),
         }
-        job = self._run_program(service, inputs=inputs)
+        job = self._run_program(service, inputs=inputs, program_id="circuit-runner")
         self.assertEqual(inputs, job.inputs)
         rjob = service.job(job.job_id())
         rinterim_results = rjob.inputs["interim_results"]
@@ -275,12 +274,10 @@ def test_job_creation_date(self, service):
     def test_job_logs(self, service):
         """Test job logs."""
         job = self._run_program(service)
-        with self.assertLogs("qiskit_ibm_runtime", "WARN"):
+        with self.assertLogs("qiskit_ibm_runtime", "INFO"):
             job.logs()
         job.wait_for_final_state()
-        job_logs = job.logs()
-        if job_logs:
-            self.assertIn("INFO Pass", job_logs)
+        self.assertTrue(job.logs())
 
     @run_integration_test
     def test_job_metrics(self, service):

test/integration/test_results.py

@@ -27,7 +27,7 @@
 class TestIntegrationResults(IBMIntegrationJobTestCase):
     """Integration tests for result callbacks."""
 
-    @skip("only supported in custom programs, not primitives")
+    @skip("skip until qiskit-ibm-runtime #933 is fixed")
     @run_integration_test
     def test_result_callback(self, service):
         """Test result callback."""
@@ -58,7 +58,7 @@ def result_callback(job_id, result):
         self.assertFalse(callback_err)
         self.assertIsNotNone(job._ws_client._server_close_code)
 
-    @skip("only supported in custom programs, not primitives")
+    @skip("skip until qiskit-ibm-runtime #933 is fixed")
     @run_integration_test
     def test_result_callback_with_job_result(self, service):
         """Test result callback along with job result."""
@@ -93,7 +93,7 @@ def result_callback(job_id, result):
         self.assertFalse(callback_err)
         self.assertIsNotNone(job._ws_client._server_close_code)
 
-    @skip("only supported in custom programs, not primitives")
+    @skip("skip until qiskit-ibm-runtime #933 is fixed")
     @run_integration_test
     def test_stream_results(self, service):
         """Test stream_results method."""
@@ -124,7 +124,7 @@ def result_callback(job_id, result):
         self.assertFalse(callback_err)
         self.assertIsNotNone(job._ws_client._server_close_code)
 
-    @skip("only supported in custom programs, not primitives")
+    @skip("skip until qiskit-ibm-runtime #933 is fixed")
     @run_integration_test
     def test_stream_results_done(self, service):
         """Test streaming results after job is done."""
@@ -149,7 +149,7 @@ def result_callback(job_id, result):
         self.assertEqual(2, called_back_count)
         self.assertIsNotNone(job._ws_client._server_close_code)
 
-    @skip("only supported in custom programs, not primitives")
+    @skip("skip until qiskit-ibm-runtime #933 is fixed")
     @run_integration_test
     def test_retrieve_interim_results(self, service):
         """Test retrieving interim results with API endpoint"""
@@ -173,7 +173,7 @@ def test_wait_for_final_state_timeout(self, service):
         with self.assertRaises(RuntimeJobTimeoutError):
             job.wait_for_final_state(0.1)
 
-    @skip("only supported in custom programs, not primitives")
+    @skip("skip until qiskit-ibm-runtime #933 is fixed")
     @run_integration_test
     def test_callback_error(self, service):
         """Test error in callback method."""

test/integration/test_retrieve_job.py

@@ -80,7 +80,7 @@ def test_retrieve_all_jobs(self, service):
         for rjob in rjobs:
             if rjob.job_id() == job.job_id():
                 self.assertEqual(job.program_id, rjob.program_id)
-                self.assertEqual(job.inputs, rjob.inputs)
+                self.assertEqual(job.result(), rjob.result())
                 found = True
                 break
         self.assertTrue(found, f"Job {job.job_id()} not returned.")
@@ -109,7 +109,7 @@ def test_retrieve_pending_jobs(self, service):
         for rjob in rjobs:
             if rjob.job_id() == job.job_id():
                 self.assertEqual(job.program_id, rjob.program_id)
-                self.assertEqual(job.inputs, rjob.inputs)
+                self.assertEqual(job.inputs["run_options"], rjob.inputs["run_options"])
                 found = True
                 break
 
@@ -128,13 +128,12 @@ def test_retrieve_returned_jobs(self, service):
         for rjob in rjobs:
             if rjob.job_id() == job.job_id():
                 self.assertEqual(job.program_id, rjob.program_id)
-                self.assertEqual(job.inputs, rjob.inputs)
+                self.assertEqual(job.result(), rjob.result())
                 found = True
                 break
         self.assertTrue(found, f"Returned job {job.job_id()} not retrieved.")
 
     @run_integration_test
-    @quantum_only
     def test_retrieve_jobs_by_program_id(self, service):
         """Test retrieving jobs by Program ID."""
         program_id = "sampler"
@@ -154,11 +153,12 @@ def test_retrieve_jobs_by_job_tags(self, service):
         self.assertFalse(rjobs)
 
     @run_integration_test
+    @quantum_only
     def test_retrieve_jobs_by_session_id(self, service):
         """Test retrieving jobs by session_id."""
-        job = self._run_program(service, start_session=True)
+        job = self._run_program(service, program_id="circuit-runner", start_session=True)
         job.wait_for_final_state()
-        job_2 = self._run_program(service, session_id=job.job_id())
+        job_2 = self._run_program(service, program_id="circuit-runner", session_id=job.job_id())
         job_2.wait_for_final_state()
         rjobs = service.jobs(session_id=job.job_id())
         self.assertEqual(2, len(rjobs), f"Retrieved jobs: {[j.job_id() for j in rjobs]}")
@@ -179,11 +179,9 @@ def test_jobs_filter_by_date(self, service):
             self.assertTrue(job.creation_date >= current_time)
 
     @run_integration_test
+    @quantum_only
     def test_jobs_filter_by_hgp(self, service):
         """Test retrieving jobs by hgp."""
-        if self.dependencies.channel == "ibm_cloud":
-            self.skipTest("Not supported on ibm_cloud")
-
         default_hgp = list(service._hgps.keys())[0]
 
         job = self._run_program(service)