classiq 0.37.0__py3-none-any.whl → 0.38.0__py3-none-any.whl

classiq/__init__.py

@@ -13,7 +13,7 @@ from classiq.interface.generator.control_state import ControlState
 from classiq.interface.generator.expressions.enums.pauli import Pauli
 from classiq.interface.generator.functions import *  # noqa: F403
 from classiq.interface.generator.functions import __all__ as _ifunc_all
-from classiq.interface.generator.generated_circuit import GeneratedCircuit
+from classiq.interface.generator.quantum_program import QuantumProgram
 from classiq.interface.ide.show import show
 
 from classiq import (
@@ -82,7 +82,7 @@ __all__ = (
         "RegisterArithmeticInfo",
         "ControlState",
         "Analyzer",
-        "GeneratedCircuit",
+        "QuantumProgram",
         "authenticate",
         "synthesize",
         "synthesize_async",

classiq/_analyzer_extras/_ipywidgets_async_extension.py

@@ -33,7 +33,7 @@ def widget_callback(widget_name: WidgetName) -> Callable[[WidgetFunc], Callable]
             interactive_loop = _create_interactive_loop_async(
                 function=function, self=self, widget=widget
             )
-            asyncio.ensure_future(interactive_loop)
+            asyncio.ensure_future(interactive_loop)  # noqa: RUF006
             await asyncio.sleep(SleepTime)
 
         return wrapper

classiq/_analyzer_extras/interactive_hardware.py

@@ -6,7 +6,7 @@ from ipywidgets import Combobox, HBox, VBox  # type: ignore[import]
 
 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.generator.quantum_program import QuantumProgram
 
 from classiq._analyzer_extras._ipywidgets_async_extension import widget_callback
 from classiq.analyzer.analyzer_utilities import (
@@ -22,7 +22,7 @@ class InteractiveHardware(AnalyzerUtilities):
     def __init__(
         self,
         params: analysis_params.AnalysisParams,
-        circuit: GeneratedCircuit,
+        circuit: QuantumProgram,
         available_devices: ProviderAvailableDevices,
         hardware_graphs: HardwareGraphs,
     ) -> None:
@@ -70,7 +70,7 @@ class InteractiveHardware(AnalyzerUtilities):
     ) -> None:
         if not provider:
             return
-        await self.request_available_devices_async(providers=[provider])
+        await self._request_available_devices_async(providers=[provider])
         self.devices_combobox.options = self._filter_devices_by_qubits_count(provider)
         self.devices_combobox.disabled = False
         self.devices_combobox.placeholder = "Choose device"

classiq/_internals/api_wrapper.py

@@ -13,8 +13,14 @@ from classiq.interface.execution.jobs import (
     ExecutionJobsQueryResultsV1,
 )
 from classiq.interface.executor import execution_request, result as execute_result
-from classiq.interface.generator import generated_circuit as generator_result
-from classiq.interface.jobs import JobDescription, JobID, JobStatus, JSONObject
+from classiq.interface.generator import quantum_program as generator_result
+from classiq.interface.jobs import (
+    JobDescriptionBase,
+    JobDescriptionFailure,
+    JobDescriptionSuccess,
+    JobID,
+    JSONObject,
+)
 from classiq.interface.model.common_model_types import ModelInput
 from classiq.interface.server import routes
 
@@ -42,13 +48,15 @@ class StatusType(Protocol):
 
 
 def _parse_job_response(
-    job_result: JobDescription[JSONObject],
+    job_result: JobDescriptionBase[JSONObject],
     output_type: Type[ResultType],
 ) -> ResultType:
-    description = job_result.description
-    if job_result.status != JobStatus.COMPLETED:
-        raise ClassiqAPIError(description["details"])
-    return output_type.parse_obj(description)
+    if isinstance(job_result, JobDescriptionSuccess):
+        return output_type.parse_obj(job_result.description)
+    if isinstance(job_result, JobDescriptionFailure):
+        raise ClassiqAPIError(job_result.description.details)
+
+    raise ClassiqAPIError("Unexpected response from server")
 
 
 class ApiWrapper:
@@ -93,14 +101,14 @@ class ApiWrapper:
     @classmethod
     async def call_generation_task(
         cls, model: ModelInput
-    ) -> generator_result.GeneratedCircuit:
+    ) -> generator_result.QuantumProgram:
         poller = JobPoller(base_url=routes.TASKS_GENERATE_FULL_PATH)
         result = await poller.run_pydantic(model, timeout_sec=None)
-        return _parse_job_response(result, generator_result.GeneratedCircuit)
+        return _parse_job_response(result, generator_result.QuantumProgram)
 
     @classmethod
     async def call_execute_generated_circuit(
-        cls, circuit: generator_result.GeneratedCircuit
+        cls, circuit: generator_result.QuantumProgram
     ) -> execution_request.ExecutionJobDetails:
         execution_input = await cls._call_task_pydantic(
             http_method=HTTPMethod.POST,
@@ -125,7 +133,7 @@ class ApiWrapper:
         cls,
         job_id: JobID,
     ) -> execution_request.ExecutionJobDetails:
-        headers = {_CONTENT_TYPE_HEADER: "v1"}
+        headers = {_ACCEPT_HEADER: "v1"}
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
             headers=headers,
@@ -215,7 +223,7 @@ class ApiWrapper:
 
     @classmethod
     async def call_analyzer_app(
-        cls, params: generator_result.GeneratedCircuit
+        cls, params: generator_result.QuantumProgram
     ) -> analysis_result.DataID:
         data = await cls._call_task_pydantic(
             http_method=HTTPMethod.POST,
@@ -227,23 +235,23 @@ class ApiWrapper:
     @classmethod
     async def get_generated_circuit_from_qasm(
         cls, params: analysis_result.QasmCode
-    ) -> generator_result.GeneratedCircuit:
+    ) -> generator_result.QuantumProgram:
         data = await cls._call_task_pydantic(
             http_method=HTTPMethod.POST,
             url=routes.IDE_QASM_FULL_PATH,
             model=params,
         )
-        return generator_result.GeneratedCircuit.parse_obj(data)
+        return generator_result.QuantumProgram.parse_obj(data)
 
     @classmethod
     async def get_analyzer_app_data(
         cls, params: analysis_result.DataID
-    ) -> generator_result.GeneratedCircuit:
+    ) -> generator_result.QuantumProgram:
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
             url=f"{routes.ANALYZER_DATA_FULL_PATH}/{params.id}",
         )
-        return generator_result.GeneratedCircuit.parse_obj(data)
+        return generator_result.QuantumProgram.parse_obj(data)
 
     @classmethod
     async def call_rb_analysis_task(

classiq/_internals/async_utils.py

@@ -1,11 +1,8 @@
-import abc
 import asyncio
 import functools
-import inspect
 import itertools
 import logging
 import time
-import types
 from typing import (
     Any,
     AsyncGenerator,
@@ -18,8 +15,6 @@ from typing import (
     Union,
 )
 
-from classiq.exceptions import ClassiqValueError
-
 T = TypeVar("T")
 ASYNC_SUFFIX = "_async"
 
@@ -58,74 +53,6 @@ def syncify_function(async_func: Callable[..., Awaitable[T]]) -> Callable[..., T
     return async_wrapper
 
 
-def maybe_syncify_property_function(obj: Any) -> Any:
-    """
-    The object is the input to `property` (or to `property.setter`)
-    Thus, we expect it to be either a function, or a function-that-returns-a-coroutine, or None
-    The only thing that should be syncified is a function-that-returns-a-coroutine
-    """
-    if inspect.iscoroutinefunction(obj):
-        return syncify_function(obj)
-    elif isinstance(obj, types.FunctionType):
-        return obj
-    elif obj is None:
-        return obj
-    else:
-        raise ClassiqValueError(f"Invalid type: {obj.__class__.__name__}")
-
-
-def syncify_property(async_prop: property) -> property:
-    if inspect.iscoroutinefunction(async_prop.fset):
-        raise ClassiqValueError(f"Setter cannot be `async def` (in {async_prop}")
-    if inspect.iscoroutinefunction(async_prop.fdel):
-        raise ClassiqValueError(f"Deleter cannot be `async def` (in {async_prop}")
-
-    return property(
-        maybe_syncify_property_function(async_prop.fget),
-        async_prop.fset,
-        async_prop.fdel,
-        async_prop.__doc__,
-    )
-
-
-# Explanation about metaclasses
-# https://stackoverflow.com/questions/100003/what-are-metaclasses-in-python
-
-
-class Asyncify(type):
-    def __new__(
-        mcls, name: str, bases: tuple, class_dict: dict  # noqa: N804
-    ) -> "Asyncify":
-        new_attrs = {}
-
-        for attr_name, attr_value in class_dict.items():
-            if attr_name.endswith(ASYNC_SUFFIX):
-                new_attr_name = attr_name[: -len(ASYNC_SUFFIX)]
-                if new_attr_name in class_dict:
-                    raise ClassiqValueError(f"Method name collision: {new_attr_name}")
-                else:
-                    new_attrs[new_attr_name] = attr_value
-
-        new_class = super().__new__(mcls, name, bases, class_dict)
-
-        for attr_name, attr_value in new_attrs.items():
-            if isinstance(attr_value, property):
-                setattr(new_class, attr_name, syncify_property(attr_value))
-            elif isinstance(attr_value, types.FunctionType):
-                setattr(new_class, attr_name, syncify_function(attr_value))
-            else:
-                raise ClassiqValueError(
-                    f"Invalid async type: {attr_value.__class__.__name__}"
-                )
-
-        return new_class
-
-
-# Used for resolving metaclass collision
-class AsyncifyABC(Asyncify, abc.ABCMeta):
-    pass
-
-
 def enable_jupyter_notebook() -> None:
     import nest_asyncio  # type: ignore[import]
 
@@ -172,7 +99,7 @@ def is_notebook() -> bool:
             return True  # Jupyter notebook or qtconsole
         elif shell == "TerminalInteractiveShell":
             return False  # Terminal running IPython
-        elif "google.colab" in str(local_ipython):
+        elif "google.colab" in str(local_ipython):  # noqa: SIM103
             return True
         else:
             return False  # Other type (?)

classiq/_internals/authentication/device.py

@@ -26,9 +26,9 @@ class DeviceRegistrar:
             get_refresh_token=get_refresh_token
         )
 
-        print(f"Your user code: {data['user_code']}")
+        print(f"Your user code: {data['user_code']}")  # noqa: T201
         verification_url = data["verification_uri_complete"]
-        print(
+        print(  # noqa: T201
             f"If a browser doesn't automatically open, please visit this URL from any trusted device: {verification_url}"
         )
         if not text_only:
@@ -68,7 +68,7 @@ class DeviceRegistrar:
         timeout: float,
         get_refresh_token: bool = True,
     ) -> Tokens:
-        async def poller():
+        async def poller() -> Dict[str, Any]:
             nonlocal device_code
             return await auth0_client.poll_tokens(device_code=device_code)
 
@@ -92,7 +92,12 @@ class DeviceRegistrar:
             elif error_code == "expired_token":
                 raise ClassiqExpiredTokenError(cls._TIMEOUT_ERROR)
             elif error_code == "access_denied":
-                error_description: str = data.get("error_description")
+                error_description = data.get("error_description")
+                if error_description is None:
+                    raise ClassiqAuthenticationError(
+                        "Failed authenticating to Classiq, missing error description"
+                    )
+
                 raise ClassiqAuthenticationError(error_description)
             else:
                 raise ClassiqAuthenticationError(

classiq/_internals/authentication/password_manager.py

@@ -9,30 +9,41 @@ from typing import Dict, Optional
 
 import keyring
 from keyring.backends import fail
+from pydantic import BaseSettings, Field
 
 _logger = logging.getLogger(__name__)
 
 
+class PasswordManagerSettings(BaseSettings):
+    ACCESS_TOKEN_KEY: str = Field(
+        default="classiqTokenAccount", env="CLASSIQ_ACCESS_TOKEN_ACCOUNT"
+    )
+    REFRESH_TOKEN_KEY: str = Field(
+        default="classiqRefershTokenAccount", env="CLASSIQ_REFRESH_TOKEN_ACCOUNT"
+    )
+
+
 class PasswordManager(abc.ABC):
     _SERVICE_NAME: str = "classiqTokenService"
-    _ACCESS_TOKEN_KEY: str = "classiqTokenAccount"
-    _REFRESH_TOKEN_KEY: str = "classiqRefershTokenAccount"
+
+    def __init__(self) -> None:
+        self._settings = PasswordManagerSettings()
 
     @property
     def access_token(self) -> Optional[str]:
-        return self._get(key=self._ACCESS_TOKEN_KEY)
+        return self._get(key=self._settings.ACCESS_TOKEN_KEY)
 
     @access_token.setter
     def access_token(self, access_token: Optional[str]) -> None:
-        self._set(key=self._ACCESS_TOKEN_KEY, value=access_token)
+        self._set(key=self._settings.ACCESS_TOKEN_KEY, value=access_token)
 
     @property
     def refresh_token(self) -> Optional[str]:
-        return self._get(key=self._REFRESH_TOKEN_KEY)
+        return self._get(key=self._settings.REFRESH_TOKEN_KEY)
 
     @refresh_token.setter
     def refresh_token(self, refresh_token: Optional[str]) -> None:
-        self._set(key=self._REFRESH_TOKEN_KEY, value=refresh_token)
+        self._set(key=self._settings.REFRESH_TOKEN_KEY, value=refresh_token)
 
     @abc.abstractmethod
     def _get(self, key: str) -> Optional[str]:
@@ -46,8 +57,9 @@ class PasswordManager(abc.ABC):
     def _clear(self, key: str) -> None:
         pass
 
+    @staticmethod
     @abc.abstractmethod
-    def is_supported(self) -> bool:
+    def is_supported() -> bool:
         pass
 
 
@@ -71,7 +83,8 @@ class KeyringPasswordManager(PasswordManager):
             username=key,
         )
 
-    def is_supported(self) -> bool:
+    @staticmethod
+    def is_supported() -> bool:
         return not isinstance(keyring.get_keyring(), fail.Keyring)
 
 
@@ -85,7 +98,8 @@ class DummyPasswordManager(PasswordManager):
     def _clear(self, key: str) -> None:
         return
 
-    def is_supported(self) -> bool:
+    @staticmethod
+    def is_supported() -> bool:
         return True
 
 
@@ -125,5 +139,6 @@ class FilePasswordManager(PasswordManager):
             token_dict.pop(key)
             self._update_file(token_dict)
 
-    def is_supported(self) -> bool:
+    @staticmethod
+    def is_supported() -> bool:
         return "windows" not in platform.platform().lower()

classiq/_internals/authentication/token_manager.py

@@ -13,7 +13,7 @@ from classiq.exceptions import (
     ClassiqPasswordManagerSelectionError,
 )
 
-PASSWORD_MANAGERS = [pm.KeyringPasswordManager(), pm.FilePasswordManager()]
+PASSWORD_MANAGERS = [pm.KeyringPasswordManager, pm.FilePasswordManager]
 _logger = logging.getLogger(__name__)
 
 
@@ -57,7 +57,7 @@ class TokenManager:
             return pm.FilePasswordManager()
         for password_manager in PASSWORD_MANAGERS:
             if password_manager.is_supported():
-                return password_manager
+                return password_manager()
         raise ClassiqPasswordManagerSelectionError(
             "Password Manager not found, we could not store your credentials securely. Please contact support@classiq.io"
         )

classiq/_internals/client.py

@@ -6,10 +6,11 @@ import os
 import platform
 import ssl
 import sys
-from typing import Any, Awaitable, Callable, Dict, NoReturn, Optional, Union
+from typing import Any, Awaitable, Callable, Dict, NoReturn, Optional, TypeVar, Union
 
 import httpx
 from packaging.version import Version
+from typing_extensions import ParamSpec
 
 from classiq.interface._version import VERSION as _VERSION
 
@@ -80,9 +81,13 @@ def _get_user_agent_header() -> Headers:
     }
 
 
+Ret = TypeVar("Ret")
+P = ParamSpec("P")
+
+
 def try_again_on_failure(
-    func: Callable[..., Awaitable[Any]]
-) -> Callable[..., Awaitable[Any]]:
+    func: Callable[P, Awaitable[Ret]]
+) -> Callable[P, Awaitable[Ret]]:
     def check_approved_api_error(error_message: str) -> bool:
         for approved_api_error in APPROVED_API_ERROR_MESSAGES_FOR_RESTART:
             if approved_api_error in error_message:
@@ -93,7 +98,7 @@ def try_again_on_failure(
         raise TypeError("Must decorate a coroutine function")
 
     @functools.wraps(func)
-    async def wrapper(*args, **kwargs):
+    async def wrapper(*args: P.args, **kwargs: P.kwargs) -> Ret:
         for i in range(_RETRY_COUNT):
             try:
                 return await func(*args, **kwargs)
@@ -123,6 +128,9 @@ def try_again_on_failure(
                     "There is problem with the connection to Classiq's server. Trying again"
                 )
                 await asyncio.sleep(API_ERROR_SLEEP_TIME)
+        raise ClassiqAPIError(
+            "Reached max retries when trying to connect to Classiq's server"
+        )
 
     return wrapper
 
@@ -186,7 +194,7 @@ class Client:
         try:
             detail = response.json()["detail"]
             message += f": {detail}"
-        except Exception:  # nosec B110
+        except Exception:  # noqa: S110
             pass
         raise ClassiqAPIError(message)
 

classiq/_internals/jobs.py

@@ -5,7 +5,12 @@ from typing import Callable, Dict, Iterable, Optional, Set, TypeVar
 import httpx
 import pydantic
 
-from classiq.interface.jobs import JobDescription, JobID, JSONObject
+from classiq.interface.jobs import (
+    JobDescriptionBase,
+    JobDescriptionUnion,
+    JobID,
+    JSONObject,
+)
 
 from classiq._internals.async_utils import poll_for
 from classiq._internals.client import client, try_again_on_failure
@@ -13,7 +18,7 @@ from classiq._internals.config import SDKMode
 from classiq.exceptions import ClassiqAPIError
 
 _URL_PATH_SEP = "/"
-GeneralJobDescription = JobDescription[JSONObject]
+GeneralJobDescription = JobDescriptionBase[JSONObject]
 _logger = logging.getLogger(__name__)
 T = TypeVar("T")
 
@@ -37,11 +42,9 @@ 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
-    )
-    if job_description.status.is_final():
-        return job_description
+    job_description = JobDescriptionUnion[JSONObject].parse_obj(json_response)
+    if job_description.__root__.status.is_final():
+        return job_description.__root__
     return None
 
 

classiq/analyzer/analyzer.py

@@ -10,16 +10,13 @@ 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.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
@@ -34,10 +31,10 @@ 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:
@@ -47,26 +44,31 @@ class Analyzer(AnalyzerUtilities, metaclass=Asyncify):
             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,7 +78,7 @@ class Analyzer(AnalyzerUtilities, metaclass=Asyncify):
             )
         )
 
-    async def get_available_devices_async(
+    def get_available_devices(
         self, providers: Optional[List[ProviderNameEnum]] = None
     ) -> Dict[ProviderNameEnum, List[DeviceName]]:
         """Returns dict of the available devices by the providers. only devices
@@ -90,13 +92,13 @@ class Analyzer(AnalyzerUtilities, metaclass=Asyncify):
         """
         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,
@@ -118,7 +120,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,7 +128,7 @@ 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,
@@ -148,10 +150,10 @@ 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,
@@ -162,12 +164,10 @@ 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,
@@ -177,9 +177,7 @@ class Analyzer(AnalyzerUtilities, metaclass=Asyncify):
             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: