Lazily fetch properties and pulse defaults only when attributes are accessed

Author: rathishcholarajan

qiskit_ibm_runtime/__init__.py

@@ -89,7 +89,7 @@
     params.measurement_error_mitigation = True
 
     # Configure backend options
-    options = {'backend_name': backend.name()}
+    options = {'backend_name': backend.name}
 
     # Execute the circuit using the "circuit-runner" program.
     job = service.run(program_id="circuit-runner",

qiskit_ibm_runtime/ibm_backend.py

@@ -84,33 +84,41 @@ def __init__(
             online_date=configuration.online_date,
             backend_version=configuration.backend_version,
         )
-
         self._configuration = configuration
         self._api_client = api_client
         self._properties = None
         self._qubit_properties = None
         self._defaults = None
-
+        self._target = None
         self._max_circuits = configuration.max_experiments
 
-        api_properties = self._api_client.backend_properties(self.name)
-        if api_properties:
-            backend_properties = properties_from_server_data(api_properties)
-            self._properties = backend_properties
-
-        api_defaults = self._api_client.backend_pulse_defaults(self.name)
-        if api_defaults:
-            self._defaults = defaults_from_server_data(api_defaults)
-
-        self._target = convert_to_target(
-            configuration=configuration.to_dict(),
-            properties=self._properties.to_dict() if api_properties else None,
-            defaults=self._defaults.to_dict() if api_defaults else None,
-        )
-
-        if api_properties:
-            self._qubit_properties = qubit_properties_dict_from_properties(
-                self._properties.to_dict()
+    def __getattr__(self, name: str) -> Any:
+        if not self._properties:
+            api_properties = self._api_client.backend_properties(self.name)
+            if api_properties:
+                backend_properties = properties_from_server_data(api_properties)
+                self._properties = backend_properties
+                if not self._qubit_properties:
+                    self._qubit_properties = qubit_properties_dict_from_properties(
+                        self._properties.to_dict()
+                    )
+        if not self._defaults:
+            api_defaults = self._api_client.backend_pulse_defaults(self.name)
+            if api_defaults:
+                self._defaults = defaults_from_server_data(api_defaults)
+        if not self._target:
+            self._target = convert_to_target(
+                configuration=self._configuration.to_dict(),
+                properties=self._properties.to_dict() if api_properties else None,
+                defaults=self._defaults.to_dict() if api_defaults else None,
+            )
+        try:
+            return super().__getattribute__(name)
+        except KeyError:
+            raise AttributeError(
+                "'{}' object has no attribute '{}'".format(
+                    self.__class__.__name__, name
+                )
             )
 
     @classmethod
@@ -164,7 +172,7 @@ def qubit_properties(
         """
         if not self._qubit_properties:
             return None
-        if isinstance(qubit, int):
+        if isinstance(qubit, int):  # type: ignore[unreachable]
             return self._qubit_properties.get(qubit)
         if isinstance(qubit, List):
             return [self._qubit_properties.get(q) for q in qubit]
@@ -217,7 +225,7 @@ def properties(
 
         if datetime or refresh or self._properties is None:
             api_properties = self._api_client.backend_properties(
-                self.name(), datetime=datetime
+                self.name, datetime=datetime
             )
             if not api_properties:
                 return None
@@ -241,7 +249,7 @@ def status(self) -> BackendStatus:
         Raises:
             IBMBackendApiProtocolError: If the status for the backend cannot be formatted properly.
         """
-        api_status = self._api_client.backend_status(self.name())
+        api_status = self._api_client.backend_status(self.name)
 
         try:
             return BackendStatus.from_dict(api_status)
@@ -266,7 +274,7 @@ def defaults(self, refresh: bool = False) -> Optional[PulseDefaults]:
             The backend pulse defaults or ``None`` if the backend does not support pulse.
         """
         if refresh or self._defaults is None:
-            api_defaults = self._api_client.backend_pulse_defaults(self.name())
+            api_defaults = self._api_client.backend_pulse_defaults(self.name)
             if api_defaults:
                 self._defaults = defaults_from_server_data(api_defaults)
             else:
@@ -292,7 +300,7 @@ def configuration(
         return self._configuration
 
     def __repr__(self) -> str:
-        return "<{}('{}')>".format(self.__class__.__name__, self.name())
+        return "<{}('{}')>".format(self.__class__.__name__, self.name)
 
     def run(self, *args: Any, **kwargs: Any) -> None:
         """Not supported method"""
@@ -335,7 +343,7 @@ def __init__(
         """
         super().__init__(configuration, api_client)
         self._status = BackendStatus(
-            backend_name=self.name(),
+            backend_name=self.name,
             backend_version=self.configuration().backend_version,
             operational=False,
             pending_jobs=0,

qiskit_ibm_runtime/ibm_runtime_service.py

@@ -90,7 +90,7 @@ class IBMRuntimeService:
         params.measurement_error_mitigation = True
 
         # Configure backend options
-        options = {'backend_name': backend.name()}
+        options = {'backend_name': backend.name}
 
         # Execute the circuit using the "circuit-runner" program.
         job = service.run(program_id="circuit-runner",
@@ -456,7 +456,7 @@ def _get_hgp(
     def _discover_backends(self) -> None:
         """Discovers the remote backends for this account, if not already known."""
         for backend in self._backends.values():
-            backend_name = to_python_identifier(backend.name())
+            backend_name = to_python_identifier(backend.name)
             # Append _ if duplicate
             while backend_name in self.__dict__:
                 backend_name += "_"

qiskit_ibm_runtime/jupyter/backend_info.py

@@ -43,7 +43,7 @@ def backend_widget(backend: Union[IBMBackend, FakeBackend]) -> None:
                     vue.ToolbarTitle(
                         children=[
                             "{} @ ({}/{}/{})".format(
-                                backend.name(), cred.hub, cred.group, cred.project
+                                backend.name, cred.hub, cred.group, cred.project
                             )
                         ],
                         style_="color:white",

qiskit_ibm_runtime/jupyter/dashboard/backend_widget.py

@@ -48,7 +48,7 @@ def make_backend_widget(backend_item: BackendWithProviders) -> wid.HBox:
     next_resrv = get_next_reservation(backend)
 
     name_str = "<font size='5' face='monospace'>%s</font>"
-    backend_name = wid.HTML(value=name_str % backend.name())
+    backend_name = wid.HTML(value=name_str % backend.name)
 
     qubits_wid = wid.HTML(value=STAT_FONT_TITLE.format("Qubits:"))
     qubits_val_wid = wid.HTML(value=STAT_FONT_VALUE.format(config.n_qubits))

qiskit_ibm_runtime/visualization/interactive/error_map.py

@@ -535,7 +535,7 @@ def iplot_error_map(
     for ann in fig["layout"]["annotations"]:
         ann["font"] = dict(size=13)
 
-    title_text = "{} Error Map".format(backend.name()) if show_title else ""
+    title_text = "{} Error Map".format(backend.name) if show_title else ""
     fig.update_layout(
         showlegend=False,
         plot_bgcolor=background_color,

qiskit_runtime/qaoa/qaoa.py

@@ -1885,7 +1885,7 @@ def __init__(
         self._coupling_map = CouplingMap(coupling_map)
         self._two_qubit_fidelity = {}
         self._max_problem_size = backend.configuration().num_qubits
-        self._name = backend.name()
+        self._name = backend.name
         self._use_fidelity = use_fidelity
 
         props = backend.properties()

test/test_backend_retrieval.py

@@ -128,7 +128,7 @@ def test_filter_least_busy(self):
         for service in services:
             with self.subTest(service=service.auth):
                 backend = service.least_busy()
-                self.assertEqual(backend.name(), "bingo")
+                self.assertEqual(backend.name, "bingo")
 
     def test_filter_min_num_qubits(self):
         """Test filtering by minimum number of qubits."""

test/test_integration_backend.py

@@ -59,34 +59,34 @@ def setUpClass(cls, devices):
     def test_backend_status(self):
         """Check the status of a real chip."""
         for backend in self.devices:
-            with self.subTest(backend=backend.name()):
+            with self.subTest(backend=backend.name):
                 self.assertTrue(backend.status().operational)
 
     def test_backend_properties(self):
         """Check the properties of calibration of a real chip."""
         for backend in self.devices:
-            with self.subTest(backend=backend.name()):
+            with self.subTest(backend=backend.name):
                 if backend.configuration().simulator:
                     raise SkipTest("Skip since simulator does not have properties.")
                 self.assertIsNotNone(backend.properties())
 
     def test_backend_pulse_defaults(self):
         """Check the backend pulse defaults of each backend."""
         for backend in self.devices:
-            with self.subTest(backend=backend.name()):
+            with self.subTest(backend=backend.name):
                 if backend.configuration().simulator:
                     raise SkipTest("Skip since simulator does not have defaults.")
                 self.assertIsNotNone(backend.defaults())
 
     def test_backend_configuration(self):
         """Check the backend configuration of each backend."""
         for backend in self.devices:
-            with self.subTest(backend=backend.name()):
+            with self.subTest(backend=backend.name):
                 self.assertIsNotNone(backend.configuration())
 
     def test_backend_run(self):
         """Check one cannot do backend.run"""
         for backend in self.devices:
-            with self.subTest(backend=backend.name()):
+            with self.subTest(backend=backend.name):
                 with self.assertRaises(RuntimeError):
                     backend.run()

test/test_integration_job.py

@@ -202,7 +202,7 @@ def test_job_inputs(self, service):
     def test_job_backend(self, service):
         """Test job backend."""
         job = self._run_program(service)
-        self.assertEqual(self.sim_backends[service.auth], job.backend.name())
+        self.assertEqual(self.sim_backends[service.auth], job.backend.name)
 
     @run_cloud_legacy_real
     def test_job_program_id(self, service):

test/test_jobs.py

@@ -87,7 +87,7 @@ def test_run_program_default_hgp_backend(self):
         default_hgp = list(service._hgps.values())[0]
         self.assertIn(backend, default_hgp.backends.keys())
         job = run_program(service=service, backend_name=backend)
-        self.assertEqual(job.backend.name(), backend)
+        self.assertEqual(job.backend.name, backend)
         self.assertEqual(
             job.backend._api_client.hgp, FakeRuntimeService.DEFAULT_HGPS[0]
         )
@@ -99,7 +99,7 @@ def test_run_program_non_default_hgp_backend(self):
         default_hgp = list(service._hgps.values())[0]
         self.assertNotIn(backend, default_hgp.backends.keys())
         job = run_program(service=service, backend_name=backend)
-        self.assertEqual(job.backend.name(), backend)
+        self.assertEqual(job.backend.name, backend)
 
     def test_run_program_by_hgp_backend(self):
         """Test running a program with both backend and hgp."""
@@ -109,7 +109,7 @@ def test_run_program_by_hgp_backend(self):
         job = run_program(
             service=service, backend_name=backend, instance=non_default_hgp
         )
-        self.assertEqual(job.backend.name(), backend)
+        self.assertEqual(job.backend.name, backend)
         self.assertEqual(job.backend._api_client.hgp, non_default_hgp)
 
     def test_run_program_by_hgp_bad_backend(self):