IQP migration followup (#2269)

* new iqp followup

* remove print

* fix use_fractional_gates bug

* add reno & fix tests

* add tests

* add test & update url logic

* update fg test

Author: kt474

qiskit_ibm_runtime/qiskit_runtime_service.py

@@ -187,16 +187,19 @@ def __init__(
         if self._channel in ["ibm_cloud", "ibm_quantum_platform"]:
             self._default_instance = False
             self._active_api_client = RuntimeClient(self._client_params)
+            self._backend_instance_groups: List[Dict[str, Any]] = []
+            self._region = region or self._account.region
+            self._plans_preference = plans_preference or self._account.plans_preference
+            self._cached_backend_objs: List[IBMBackend] = []
+            if self._account.instance:
+                self._default_instance = True
             if instance is not None:
                 self._api_clients = {instance: RuntimeClient(self._client_params)}
             else:
                 self._api_clients = {}
-            self._cached_backend_objs: List[IBMBackend] = []
-            if self._account.instance:
-                self._default_instance = True
-            self._backend_instance_groups: List[Dict[str, Any]] = []
-            self._region = region or self._account.region
-            self._plans_preference = plans_preference or self._account.plans_preference
+                instance_backends = self._resolve_cloud_instances(instance)
+                for inst, _ in instance_backends:
+                    self._get_or_create_cloud_client(inst)
 
         else:
             warnings.warn(
@@ -790,6 +793,20 @@ def _create_backend_obj(
                 "ibm_quantum_platform",
             ]:
                 config = self._backend_configs[backend_name]
+                # if cached config does not match use_fractional_gates
+                if (
+                    use_fractional_gates
+                    and "rzz" not in config.basis_gates
+                    or not use_fractional_gates
+                    and "rzz" in config.basis_gates
+                ):
+                    config = configuration_from_server_data(
+                        raw_config=self._active_api_client.backend_configuration(backend_name),
+                        instance=instance,
+                        use_fractional_gates=use_fractional_gates,
+                    )
+                    self._backend_configs[backend_name] = config
+
             else:
                 config = configuration_from_server_data(
                     raw_config=self._active_api_client.backend_configuration(backend_name),
@@ -1251,7 +1268,6 @@ def jobs(
         job_responses = []  # type: List[Dict[str, Any]]
         current_page_limit = limit or 20
         offset = skip
-
         while True:
             jobs_response = self._active_api_client.jobs_get(
                 limit=current_page_limit,

qiskit_ibm_runtime/utils/utils.py

@@ -342,12 +342,10 @@ def default_runtime_url_resolver(
         elif channel == "ibm_quantum_platform":
             # ibm_quantum_platform url
             region = _location_from_crn(instance)
-            if region == "eu-de":
-                api_host = (
-                    f"{parsed_url.scheme}://{region}" f".quantum.{parsed_url.hostname}/api/v1"
-                )
-            else:
-                api_host = f"{parsed_url.scheme}://" f"quantum.{parsed_url.hostname}/api/v1"
+            region_prefix = "" if region == "us-east" else f"{region}."
+            api_host = (
+                f"{parsed_url.scheme}://{region_prefix}" f"quantum.{parsed_url.hostname}/api/v1"
+            )
         else:
             # ibm_cloud url
             api_host = (

release-notes/unreleased/2269.bug.rst

@@ -0,0 +1,5 @@
+Fixed an issue where if there was no instance saved nor passed in at initialization, the service could not make
+any api calls until :meth:`.QiskitRuntimeService.backend` or :meth:`.QiskitRuntimeService.backends` is called first.
+
+Fixed a bug where if ``use_fractional_gates`` is set but the backend configuration was already cached, 
+the incorrect configuration could be returned.

test/integration/test_account.py

@@ -143,6 +143,35 @@ def test_instances(self):
         self.assertTrue(instances[0]["crn"])
         self.assertTrue(instances[0]["name"])
 
+    def test_jobs_before_backend(self):
+        """Test retrieving jobs before backends call."""
+        service = QiskitRuntimeService(
+            token=self.dependencies.token, channel="ibm_quantum_platform", url=self.dependencies.url
+        )
+        self.assertTrue(service._all_instances)
+        jobs = service.jobs()
+        self.assertTrue(jobs)
+        job = jobs[0]
+        self.assertTrue(job.result())
+
+    def test_jobs_different_instances(self):
+        """Test retrieving jobs from different instances."""
+        service = QiskitRuntimeService(
+            token=self.dependencies.token, channel="ibm_quantum_platform", url=self.dependencies.url
+        )
+        instances = service.instances()
+        for instance in instances:
+            instance_service = QiskitRuntimeService(
+                token=self.dependencies.token,
+                instance=instance["crn"],
+                channel="ibm_quantum_platform",
+                url=self.dependencies.url,
+            )
+            jobs = instance_service.jobs()
+            if jobs:
+                instance_job = jobs[0].job_id()
+                self.assertTrue(service.job(instance_job))
+
 
 class TestIntegrationAccount(IBMIntegrationTestCase):
     """Integration tests for account management."""

test/integration/test_backend.py

@@ -321,3 +321,14 @@ def test_too_many_qubits_in_circuit(self):
             f"circuit has {num_qubits} qubits but the target system requires {num}",
             str(err.exception),
         )
+
+    def test_use_fractional_gates_flag(self):
+        """Test use_fractional_gates returns correct backend config."""
+        try:
+            real_device_name = "alt_fez"
+            real_device_no_fg = self.service.backend(real_device_name, use_fractional_gates=False)
+            real_device_fg = self.service.backend(real_device_name, use_fractional_gates=True)
+        except QiskitBackendNotFoundError:
+            self.skipTest("Real backend not available.")
+        self.assertIn("rzz", real_device_fg.basis_gates)
+        self.assertNotIn("rzz", real_device_no_fg.basis_gates)

test/unit/test_account.py

@@ -18,6 +18,7 @@
 import uuid
 from typing import Any
 from unittest import skipIf
+from unittest.mock import patch
 from ddt import ddt, data
 
 from qiskit_ibm_runtime.proxies import ProxyConfiguration
@@ -730,7 +731,8 @@ def test_enable_cloud_account_by_channel_token_url(self):
         for url in urls:
             with self.subTest(url=url), no_envs(["QISKIT_IBM_TOKEN"]):
                 token = uuid.uuid4().hex
-                service = FakeRuntimeService(channel="ibm_cloud", token=token, url=url)
+                with patch.object(FakeRuntimeService, "_resolve_cloud_instances", return_value=[]):
+                    service = FakeRuntimeService(channel="ibm_cloud", token=token, url=url)
                 self.assertTrue(service)
 
     def test_enable_ibm_quantum_account_by_channel_token_url(self):