classiq 0.37.1__py3-none-any.whl → 0.65.3__py3-none-any.whl

classiq/_internals/host_checker.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import logging
+import warnings
+from datetime import datetime
 from typing import TYPE_CHECKING, Optional
 
 import httpx
@@ -8,10 +10,10 @@ import pydantic
 from packaging.version import Version
 from pydantic import BaseModel
 
+from classiq.interface.exceptions import ClassiqAPIError, ClassiqDeprecationWarning
+from classiq.interface.interface_version import INTERFACE_VERSION
 from classiq.interface.server.global_versions import DeprecationInfo, GlobalVersions
 
-from classiq.exceptions import ClassiqAPIError
-
 if TYPE_CHECKING:
     from classiq._internals.client import Client
 
@@ -26,16 +28,32 @@ class HostVersions(BaseModel):
 class HostChecker:
     _UNKNOWN_VERSION = "0.0.0"
 
-    def __init__(self, client: Client, client_version: str) -> None:
+    def __init__(
+        self,
+        client: Client,
+        client_version: str,
+        interface_version: str = INTERFACE_VERSION,
+    ) -> None:
         self._client = client
         self._client_version = client_version
+        self._interface_version = interface_version
+
+    def _get_interface_version(self) -> Optional[str]:
+        global_interfaces = GlobalVersions.model_validate(
+            self._client.sync_call_api(
+                "get", "/interface_versions", use_versioned_url=False
+            )
+        )
+        return global_interfaces.deployed.get(self._interface_version, None)
 
     def _get_host_version(self) -> str:
-        host = HostVersions.parse_obj(self._client.sync_call_api("get", "/versions"))
+        host = HostVersions.model_validate(
+            self._client.sync_call_api("get", "/versions")
+        )
         return host.classiq_interface
 
     def _get_deprecation_info(self) -> Optional[DeprecationInfo]:
-        global_versions = GlobalVersions.parse_obj(
+        global_versions = GlobalVersions.model_validate(
             self._client.sync_call_api("get", "/versions", use_versioned_url=False)
         )
         return global_versions.deprecated.get(self._client_version, None)
@@ -56,18 +74,16 @@ class HostChecker:
 
     def check_host_version(self) -> None:
         try:
-            raw_host_version = self._get_host_version()
+            interface_version = self._get_interface_version()
         except httpx.ConnectError:
             _logger.warning(
                 "Version check failed - host unavailable.",
             )
         else:
-            if not self._check_matching_versions(
-                raw_host_version, self._client_version
-            ):
+            if interface_version is None:
                 raise ClassiqAPIError(
-                    f"Classiq API version mismatch: 'classiq' version is "
-                    f"{self._client_version}, backend version is {raw_host_version}. {_VERSION_UPDATE_SUGGESTION}"
+                    f"You are using an unsupported version of Classiq SDK - {self._client_version}. "
+                    f"{_VERSION_UPDATE_SUGGESTION}"
                 )
 
     def check_deprecated_version(self) -> None:
@@ -80,8 +96,15 @@ class HostChecker:
         else:
             if deprecation_info is None:
                 return
-            _logger.warning(
-                "The current version of 'classiq' has been deprecated, and will not be supported as of %s. %s",
-                deprecation_info.removal_date.date(),
-                _VERSION_UPDATE_SUGGESTION,
+            removal_date = (
+                deprecation_info.removal_date.date()
+                if isinstance(deprecation_info.removal_date, datetime)
+                else deprecation_info.removal_date
+            )
+            warnings.warn(
+                f"The current version of 'classiq' has been deprecated, and"
+                f" will not be supported as of {removal_date}. "
+                f"{_VERSION_UPDATE_SUGGESTION}",
+                ClassiqDeprecationWarning,
+                stacklevel=2,
             )

classiq/_internals/jobs.py

@@ -1,16 +1,17 @@
 import json
 import logging
-from typing import Callable, Dict, Iterable, Optional, Set, TypeVar
+from collections.abc import Iterable
+from typing import Callable, Optional, TypeVar
 
 import httpx
 import pydantic
 
+from classiq.interface.exceptions import ClassiqAPIError
 from classiq.interface.jobs import JobDescription, JobID, JSONObject
 
 from classiq._internals.async_utils import poll_for
-from classiq._internals.client import client, try_again_on_failure
+from classiq._internals.client import client
 from classiq._internals.config import SDKMode
-from classiq.exceptions import ClassiqAPIError
 
 _URL_PATH_SEP = "/"
 GeneralJobDescription = JobDescription[JSONObject]
@@ -37,28 +38,24 @@ def _join_url_path(*parts: str) -> str:
 def _general_job_description_parser(
     json_response: JSONObject,
 ) -> Optional[GeneralJobDescription]:
-    job_description: GeneralJobDescription = GeneralJobDescription.parse_obj(
-        json_response
-    )
+    job_description = GeneralJobDescription.model_validate(json_response)
     if job_description.status.is_final():
         return job_description
     return None
 
 
 class JobPoller:
-    INITIAL_INTERVAL_SEC = 1
-    INTERVAL_FACTOR = 2
-    FINAL_INTERVAL_SEC = INITIAL_INTERVAL_SEC * INTERVAL_FACTOR**5  # 32 secs
+    INITIAL_INTERVAL_SEC = 0.1
+    INTERVAL_FACTOR = 1.5
+    FINAL_INTERVAL_SEC = 25
     DEV_INTERVAL = 0.05
 
     def __init__(
         self,
         base_url: str,
-        required_headers: Optional[Set[str]] = None,
         use_versioned_url: bool = True,
-        additional_headers: Optional[Dict[str, str]] = None,
+        additional_headers: Optional[dict[str, str]] = None,
     ) -> None:
-        self._required_headers = required_headers or set()
         self._additional_headers = additional_headers
         client_instance = client()
         self._base_url = (
@@ -66,11 +63,10 @@ class JobPoller:
             if use_versioned_url
             else base_url
         )
-        self._async_client = client_instance.async_client()
         self._mode = client_instance.config.mode
 
     def _parse_job_id_response(self, response: httpx.Response) -> JobID:
-        return JobID.parse_obj(response.json())
+        return JobID.model_validate(response.json())
 
     def _make_poll_url(self, job_id: JobID) -> str:
         return _join_url_path(self._base_url, job_id.job_id)
@@ -79,37 +75,33 @@ class JobPoller:
     def _make_cancel_url(poll_url: str) -> str:
         return _join_url_path(poll_url, "cancel")
 
-    def _update_headers(self, response: httpx.Response) -> None:
-        for header in self._required_headers:
-            try:
-                self._async_client.headers[header] = response.headers[header]
-            except KeyError as exc:
-                raise ClassiqAPIError(
-                    f"Response to {self._base_url} is missing header {header}"
-                ) from exc
-
-    @try_again_on_failure
     async def _request(
-        self, http_method: str, url: str, body: Optional[Dict] = None
+        self,
+        http_client: httpx.AsyncClient,
+        http_method: str,
+        url: str,
+        body: Optional[dict] = None,
     ) -> httpx.Response:
-        # Update headers in case they change
-        self._async_client.headers.update(client().get_headers())
-        response = await self._async_client.request(
-            method=http_method, url=url, json=body, headers=self._additional_headers
+        return await client().request(
+            http_client=http_client,
+            method=http_method,
+            url=url,
+            json=body,
+            headers=self._additional_headers,
         )
-        client().handle_response(response)
-        return response
 
-    async def _submit(self, body: Dict) -> httpx.Response:
-        return await self._request(http_method="POST", url=self._base_url, body=body)
+    async def _submit(
+        self, http_client: httpx.AsyncClient, body: dict
+    ) -> httpx.Response:
+        return await self._request(
+            http_client=http_client, http_method="POST", url=self._base_url, body=body
+        )
 
     def _interval_sec(self) -> Iterable[float]:
         if self._mode == SDKMode.DEV:
             while True:
                 yield self.DEV_INTERVAL
         else:
-            for _ in range(10):
-                yield self.INITIAL_INTERVAL_SEC
             interval = self.INITIAL_INTERVAL_SEC
             while True:
                 yield interval
@@ -117,13 +109,16 @@ class JobPoller:
 
     async def _poll(
         self,
+        http_client: httpx.AsyncClient,
         poll_url: str,
         timeout_sec: Optional[float],
         response_parser: Callable[[JSONObject], Optional[T]] = _general_job_description_parser,  # type: ignore[assignment]
     ) -> T:
         async def poller() -> JSONObject:
             nonlocal self, poll_url
-            raw_response = await self._request(http_method="GET", url=poll_url)
+            raw_response = await self._request(
+                http_client=http_client, http_method="GET", url=poll_url
+            )
             return raw_response.json()
 
         async for json_response in poll_for(
@@ -139,39 +134,50 @@ class JobPoller:
         job_id: JobID,
         timeout_sec: Optional[float],
         response_parser: Callable[[JSONObject], Optional[T]] = _general_job_description_parser,  # type: ignore[assignment]
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> T:
         poll_url = self._make_poll_url(job_id=job_id)
-        async with self._async_client:
+        async with client().use_client_or_create(http_client) as async_client:
             return await self._poll(
+                http_client=async_client,
                 poll_url=poll_url,
                 response_parser=response_parser,
                 timeout_sec=timeout_sec,
             )
 
-    async def _cancel(self, poll_url: str) -> None:
+    async def _cancel(self, http_client: httpx.AsyncClient, poll_url: str) -> None:
         _logger.info("Cancelling job %s", poll_url, exc_info=True)
         cancel_url = self._make_cancel_url(poll_url)
-        await self._request(http_method="PUT", url=cancel_url)
+        await self._request(http_client=http_client, http_method="PUT", url=cancel_url)
 
     async def run(
-        self, body: Dict, timeout_sec: Optional[float]
+        self,
+        body: dict,
+        timeout_sec: Optional[float],
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> GeneralJobDescription:
-        async with self._async_client:
-            submit_response = await self._submit(body=body)
+        async with client().use_client_or_create(http_client) as async_client:
+            submit_response = await self._submit(http_client=async_client, body=body)
             job_id = self._parse_job_id_response(response=submit_response)
             poll_url = self._make_poll_url(job_id=job_id)
-            self._update_headers(response=submit_response)
             try:
-                return await self._poll(poll_url=poll_url, timeout_sec=timeout_sec)
+                return await self._poll(
+                    http_client=async_client,
+                    poll_url=poll_url,
+                    timeout_sec=timeout_sec,
+                )
             except Exception:
-                await self._cancel(poll_url=poll_url)
+                await self._cancel(http_client=async_client, poll_url=poll_url)
                 raise
 
     async def run_pydantic(
-        self, model: pydantic.BaseModel, timeout_sec: Optional[float]
+        self,
+        model: pydantic.BaseModel,
+        timeout_sec: Optional[float],
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> GeneralJobDescription:
         # TODO: we can't use model.dict() - it doesn't serialize complex class.
-        # This was added because JSON serializer doesn't serialize complex type, and pydantic does.
-        # We should add support for smarter json serialization.
-        body = json.loads(model.json())
-        return await self.run(body, timeout_sec)
+        # This was added because JSON serializer doesn't serialize complex and UUID,
+        # while pydantic does. We should add support for smarter json serialization.
+        body = json.loads(model.model_dump_json())
+        return await self.run(body, timeout_sec, http_client=http_client)

classiq/_internals/type_validation.py

@@ -1,4 +1,4 @@
-from typing import Any, Tuple, Type, TypeVar, Union, overload
+from typing import Any, TypeVar, Union, overload
 
 T = TypeVar("T")
 U = TypeVar("U")
@@ -10,37 +10,37 @@ U = TypeVar("U")
 
 @overload
 def validate_type(
-    obj: Any, expected_type: Type[T], operation: str, exception_type: Type[Exception]
+    obj: Any, expected_type: type[T], operation: str, exception_type: type[Exception]
 ) -> T: ...
 
 
 @overload
 def validate_type(
     obj: Any,
-    expected_type: Tuple[Type[T], Type[U]],
+    expected_type: tuple[type[T], type[U]],
     operation: str,
-    exception_type: Type[Exception],
+    exception_type: type[Exception],
 ) -> Union[T, U]: ...
 
 
 @overload
 def validate_type(
     obj: Any,
-    expected_type: Tuple[Type[T], ...],
+    expected_type: tuple[type[T], ...],
     operation: str,
-    exception_type: Type[Exception],
+    exception_type: type[Exception],
 ) -> Any: ...
 
 
 def validate_type(
     obj: Any,
-    expected_type: Union[Tuple[type, ...], type],
+    expected_type: Union[tuple[type, ...], type],
     operation: str,
-    exception_type: Type[Exception],
+    exception_type: type[Exception],
 ) -> Any:
     operation = operation[0].upper() + operation[1:]
     if not isinstance(obj, expected_type):
-        expected_types: Tuple[type, ...]
+        expected_types: tuple[type, ...]
         if isinstance(expected_type, type):
             expected_types = (expected_type,)
         else:

classiq/analyzer/__init__.py

@@ -1,5 +1,3 @@
-from typing import List
-
 import classiq.analyzer.show_interactive_hack
 from classiq.analyzer.analyzer import Analyzer
 
@@ -8,5 +6,5 @@ from ..analyzer import rb
 __all__ = ["rb"]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return ["rb"]

classiq/analyzer/analyzer.py

@@ -2,28 +2,26 @@
 
 import json
 import webbrowser
+from collections.abc import Sequence
 from importlib.util import find_spec
-from typing import Any, Dict, List, Optional, Sequence, Union
+from typing import Any, Optional, Union
 from urllib.parse import urljoin
 
 import plotly.graph_objects as go
 
 from classiq.interface.analyzer import analysis_params
 from classiq.interface.backend.quantum_backend_providers import AnalyzerProviderVendor
-from classiq.interface.generator import generated_circuit as generator_result
+from classiq.interface.exceptions import ClassiqAnalyzerError
+from classiq.interface.generator import quantum_program as generator_result
 
-from classiq._internals import client
+from classiq._internals import async_utils, client
 from classiq._internals.api_wrapper import ApiWrapper
-from classiq._internals.async_utils import Asyncify
 from classiq.analyzer.analyzer_utilities import (
     AnalyzerUtilities,
     DeviceName,
-    HardwareGraphs,
-    ProviderAvailableDevices,
     ProviderNameEnum,
 )
 from classiq.analyzer.url_utils import circuit_page_uri, client_ide_base_url
-from classiq.exceptions import ClassiqAnalyzerError
 
 find_ipywidgets = find_spec("ipywidgets")
 VBox = Any
@@ -34,39 +32,44 @@ if find_ipywidgets is not None:
     from classiq._analyzer_extras.interactive_hardware import InteractiveHardware
 
 
-class Analyzer(AnalyzerUtilities, metaclass=Asyncify):
+class Analyzer(AnalyzerUtilities):
     """Analyzer is the wrapper object for all analysis capabilities."""
 
-    def __init__(self, circuit: generator_result.GeneratedCircuit) -> None:
+    def __init__(self, circuit: generator_result.QuantumProgram) -> None:
         """Init self.
 
         Args:
-            circuit (): The circuit to be analyzed.
+            circuit: The circuit to be analyzed.
         """
         if circuit.qasm is None:
             raise ClassiqAnalyzerError(
                 "Analysis requires a circuit with valid QASM code"
             )
-        self._params: analysis_params.AnalysisParams = analysis_params.AnalysisParams(
+        params: analysis_params.AnalysisParams = analysis_params.AnalysisParams(
             qasm=circuit.qasm
         )
-        self.circuit: generator_result.GeneratedCircuit = circuit
+        super().__init__(
+            params=params,
+            circuit=circuit,
+            available_devices=dict(),
+            hardware_graphs=dict(),
+        )
+
         self.hardware_comparison_table: Optional[go.Figure] = None
-        self.available_devices: ProviderAvailableDevices = dict()
-        self.hardware_graphs: HardwareGraphs = dict()
 
         self.transpilation_params = analysis_params.AnalysisHardwareTranspilationParams(
             hardware_data=self.circuit.hardware_data,
-            model_preferences=self.circuit.model.preferences,
+            random_seed=self.circuit.model.execution_preferences.random_seed,
+            transpilation_option=self.circuit.model.execution_preferences.transpile_to_hardware,
         )
 
-    async def analyzer_app_async(self) -> None:
+    def analyzer_app(self) -> None:
         """Opens the analyzer app with synthesis interactive results.
 
         Returns:
             None.
         """
-        result = await ApiWrapper.call_analyzer_app(self.circuit)
+        result = async_utils.run(ApiWrapper.call_analyzer_app(self.circuit))
         webbrowser.open_new_tab(
             urljoin(
                 client_ide_base_url(),
@@ -76,27 +79,29 @@ class Analyzer(AnalyzerUtilities, metaclass=Asyncify):
             )
         )
 
-    async def get_available_devices_async(
-        self, providers: Optional[List[ProviderNameEnum]] = None
-    ) -> Dict[ProviderNameEnum, List[DeviceName]]:
-        """Returns dict of the available devices by the providers. only devices
+    def get_available_devices(
+        self, providers: Optional[list[ProviderNameEnum]] = None
+    ) -> dict[ProviderNameEnum, list[DeviceName]]:
+        """Deprecated. Use get_all_hardware_devices instead.
+
+        Returns dict of the available devices by the providers. only devices
         with sufficient number of qubits are returns
 
-        Args: providers (): List of providers (string or `AnalyzerProviderVendor`).
+        Args: providers: List of providers.
         if None, the table include all the available hardware.
 
         Returns:
-            available devices (): dict of the available devices (Dict[str,List[str]]).
+            available devices: dict of the available devices.
         """
         if providers is None:
             providers = list(AnalyzerProviderVendor)
-        await self.request_available_devices_async(providers=providers)
+        async_utils.run(self._request_available_devices_async(providers=providers))
         return {
             provider: self._filter_devices_by_qubits_count(provider)
             for provider in providers
         }
 
-    async def plot_hardware_connectivity_async(
+    def plot_hardware_connectivity(
         self,
         provider: Optional[ProviderNameEnum] = None,
         device: Optional[DeviceName] = None,
@@ -105,10 +110,10 @@ class Analyzer(AnalyzerUtilities, metaclass=Asyncify):
         analyzer_sdk extra.
 
         Args:
-            provider (): provider name (optional - string or `AnalyzerProviderVendor`).
-            device (): device name (optional - string).
+            provider: provider name.
+            device: device name.
         Returns:
-         hardware_connectivity_graph (): interactive graph.
+         hardware_connectivity_graph: interactive graph.
         """
 
         self._validate_analyzer_extra()
@@ -118,7 +123,7 @@ class Analyzer(AnalyzerUtilities, metaclass=Asyncify):
             available_devices=self.available_devices,
             hardware_graphs=self.hardware_graphs,
         )
-        await interactive_hardware.enable_interactivity_async()
+        async_utils.run(interactive_hardware.enable_interactivity_async())
         if provider is not None:
             interactive_hardware.providers_combobox.value = provider
             if device is not None:
@@ -126,19 +131,21 @@ class Analyzer(AnalyzerUtilities, metaclass=Asyncify):
 
         return interactive_hardware.show_interactive_graph()
 
-    async def get_hardware_comparison_table_async(
+    def get_hardware_comparison_table(
         self,
         providers: Optional[Sequence[Union[str, AnalyzerProviderVendor]]] = None,
-        devices: Optional[List[str]] = None,
+        devices: Optional[list[str]] = None,
     ) -> None:
         """create a comparison table between the transpiled circuits result on different hardware.
         The  comparison table included the depth, multi qubit gates count,and total gates count of the circuits.
 
-        Args: providers (): List of providers (string or `AnalyzerProviderVendor`). if None, the table include all
-        the available hardware.
-        devices (): List of devices (string). if None, the table include all the available devices of the selected
+        Args:
+            providers: List of providers. if None, the table include all the available hardware.
+            devices: List of devices. if None, the table include all the available devices of the selected
         providers.
-        Returns: None.
+
+        Returns:
+            None.
         """
         if providers is None:
             providers = list(AnalyzerProviderVendor)
@@ -148,13 +155,13 @@ class Analyzer(AnalyzerUtilities, metaclass=Asyncify):
             devices=devices,
             transpilation_params=self.transpilation_params,
         )
-        result = await ApiWrapper.call_table_graphs_task(params=params)
+        result = async_utils.run(ApiWrapper.call_table_graphs_task(params=params))
         self.hardware_comparison_table = go.Figure(json.loads(result.details))
 
-    async def plot_hardware_comparison_table_async(
+    def plot_hardware_comparison_table(
         self,
-        providers: Optional[List[Union[str, AnalyzerProviderVendor]]] = None,
-        devices: Optional[List[str]] = None,
+        providers: Optional[list[Union[str, AnalyzerProviderVendor]]] = None,
+        devices: Optional[list[str]] = None,
     ) -> None:
         """plot the comparison table. if it has not been created it, it first creates the table using all the
         available hardware.
@@ -162,24 +169,20 @@ class Analyzer(AnalyzerUtilities, metaclass=Asyncify):
         Returns:
             None.
         """
-        await self._hardware_comparison_condition_async(
-            providers=providers, devices=devices
-        )
+        self._hardware_comparison_condition(providers=providers, devices=devices)
         self.hardware_comparison_table.show()  # type: ignore[union-attr]
 
-    async def _hardware_comparison_condition_async(
+    def _hardware_comparison_condition(
         self,
         providers: Optional[Sequence[Union[str, AnalyzerProviderVendor]]] = None,
-        devices: Optional[List[str]] = None,
+        devices: Optional[list[str]] = None,
     ) -> None:
         if (
             providers is not None
             or devices is not None
             or self.hardware_comparison_table is None
         ):
-            await self.get_hardware_comparison_table_async(
-                providers=providers, devices=devices
-            )
+            self.get_hardware_comparison_table(providers=providers, devices=devices)
 
     @staticmethod
     def _open_route(path: str) -> None:

classiq/analyzer/analyzer_utilities.py

@@ -1,11 +1,11 @@
-from typing import Dict, List, Union
+from typing import Union
 
 from classiq.interface.analyzer import analysis_params
 from classiq.interface.backend.quantum_backend_providers import AnalyzerProviderVendor
-from classiq.interface.generator.generated_circuit import GeneratedCircuit
+from classiq.interface.exceptions import ClassiqAnalyzerError
+from classiq.interface.generator.quantum_program import QuantumProgram
 
 from classiq._internals.api_wrapper import ApiWrapper
-from classiq.exceptions import ClassiqAnalyzerError
 
 DeviceName = str
 ProviderName = str
@@ -13,26 +13,26 @@ ProviderLowerName = str
 HardwareGraphJson = str
 Availability = bool
 ProviderNameEnum = Union[ProviderName, AnalyzerProviderVendor]
-AvailableDevices = Dict[DeviceName, Availability]
-ProviderAvailableDevices = Dict[ProviderLowerName, AvailableDevices]
-HardwareGraphs = Dict[DeviceName, HardwareGraphJson]
+AvailableDevices = dict[DeviceName, Availability]
+ProviderAvailableDevices = dict[ProviderLowerName, AvailableDevices]
+HardwareGraphs = dict[DeviceName, HardwareGraphJson]
 
 
 class AnalyzerUtilities:
     def __init__(
         self,
         params: analysis_params.AnalysisParams,
-        circuit: GeneratedCircuit,
+        circuit: QuantumProgram,
         available_devices: ProviderAvailableDevices,
         hardware_graphs: HardwareGraphs,
     ) -> None:
         self._params: analysis_params.AnalysisParams = params
-        self.circuit: GeneratedCircuit = circuit
+        self.circuit: QuantumProgram = circuit
         self.available_devices = available_devices
         self.hardware_graphs = hardware_graphs
 
-    async def request_available_devices_async(
-        self, providers: List[ProviderNameEnum]
+    async def _request_available_devices_async(
+        self, providers: list[ProviderNameEnum]
     ) -> None:
         requested_providers = self._requested_providers_filter(providers)
         if not requested_providers:
@@ -41,7 +41,7 @@ class AnalyzerUtilities:
             qubit_count=self.circuit.data.width, providers=requested_providers
         )
         result = await ApiWrapper.call_available_devices_task(params=params)
-        self.available_devices.update(result.devices.dict())
+        self.available_devices.update(result.devices.model_dump())
 
     async def request_hardware_connectivity_async(
         self, provider: ProviderNameEnum, device: DeviceName
@@ -58,7 +58,7 @@ class AnalyzerUtilities:
     async def _device_validation_async(
         self, provider: ProviderNameEnum, device: DeviceName
     ) -> None:
-        await self.request_available_devices_async(providers=[provider])
+        await self._request_available_devices_async(providers=[provider])
         provider_lower_name = _to_lower_case(provider)
         available_device_dict = self.available_devices
         if available_device_dict[provider_lower_name].get(device) is False:
@@ -69,8 +69,8 @@ class AnalyzerUtilities:
             )
 
     def _requested_providers_filter(
-        self, providers: List[ProviderNameEnum]
-    ) -> List[ProviderNameEnum]:
+        self, providers: list[ProviderNameEnum]
+    ) -> list[ProviderNameEnum]:
         return list(
             filter(
                 lambda provider: self.available_devices.get(_to_lower_case(provider))
@@ -81,7 +81,7 @@ class AnalyzerUtilities:
 
     def _filter_devices_by_qubits_count(
         self, provider: ProviderNameEnum
-    ) -> List[DeviceName]:
+    ) -> list[DeviceName]:
         device_avail_dict = self.available_devices[_to_lower_case(provider)]
         return list(
             filter(lambda device: device_avail_dict[device], device_avail_dict.keys())