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

classiq/__init__.py

@@ -1,6 +1,5 @@
 """Classiq SDK."""
 
-import sys
 from typing import List
 
 from classiq.interface._version import VERSION as _VERSION
@@ -13,17 +12,12 @@ 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.model import *  # noqa: F403
+from classiq.interface.generator.model import __all__ as _md_all
+from classiq.interface.generator.quantum_program import QuantumProgram
 from classiq.interface.ide.show import show
 
-from classiq import (
-    applications,
-    builtin_functions,
-    exceptions,
-    execution,
-    model,
-    synthesis,
-)
+from classiq import applications, exceptions, execution, synthesis
 from classiq._internals import _qfunc_ext, logger
 from classiq._internals.async_utils import (
     enable_jupyter_notebook,
@@ -34,23 +28,23 @@ from classiq._internals.client import configure
 from classiq._internals.config import Configuration
 from classiq._internals.help import open_help
 from classiq.analyzer import Analyzer
-from classiq.applications_model_constructors import *  # noqa: F403
-from classiq.applications_model_constructors import (
-    __all__ as _application_constructors_all,
+from classiq.applications.chemistry import (
+    construct_chemistry_model,
+    molecule_problem_to_qmod,
+)
+from classiq.applications.combinatorial_optimization import (
+    construct_combinatorial_optimization_model,
 )
+from classiq.applications.finance import construct_finance_model
+from classiq.applications.grover import construct_grover_model
+from classiq.applications.qsvm import construct_qsvm_model
 from classiq.executor import (
     execute,
     execute_async,
     set_quantum_program_execution_preferences,
 )
-from classiq.model import *  # noqa: F403
-from classiq.model import __all__ as _md_all
 from classiq.qmod import *  # noqa: F403
 from classiq.qmod import __all__ as _qmod_all
-from classiq.quantum_functions import *  # noqa: F403
-from classiq.quantum_functions import __all__ as _qfuncs_all
-from classiq.quantum_register import *  # noqa: F403
-from classiq.quantum_register import __all__ as _qregs_all
 from classiq.synthesis import (
     set_constraints,
     set_execution_preferences,
@@ -59,6 +53,15 @@ from classiq.synthesis import (
     synthesize_async,
 )
 
+_application_constructors_all = [
+    "construct_qsvm_model",
+    "construct_combinatorial_optimization_model",
+    "construct_chemistry_model",
+    "construct_finance_model",
+    "construct_grover_model",
+    "molecule_problem_to_qmod",
+]
+
 __version__ = _VERSION
 
 if _is_notebook():
@@ -67,10 +70,8 @@ if _is_notebook():
 _sub_modules = [
     "analyzer",
     "applications",
-    "builtin_functions",
     "exceptions",
     "execution",
-    "model",
     "open_help",
     "qmod",
     "synthesis",
@@ -82,7 +83,7 @@ __all__ = (
         "RegisterArithmeticInfo",
         "ControlState",
         "Analyzer",
-        "GeneratedCircuit",
+        "QuantumProgram",
         "authenticate",
         "synthesize",
         "synthesize_async",
@@ -95,8 +96,6 @@ __all__ = (
         "show",
         "Pauli",
     ]
-    + _qregs_all
-    + _qfuncs_all
     + _md_all
     + _ifunc_all
     + _sub_modules

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

@@ -1,5 +1,5 @@
 import json
-from typing import Dict, Optional, Protocol, Type, TypeVar
+from typing import Dict, List, Optional, Protocol, Type, TypeVar
 
 import pydantic
 
@@ -13,8 +13,15 @@ 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.hardware import HardwareInformation
+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 +49,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 +102,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 +134,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 +224,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 +236,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(
@@ -289,6 +298,17 @@ class ApiWrapper:
         )
         return analysis_result.DevicesResult.parse_obj(data)
 
+    @classmethod
+    async def call_get_all_hardware_devices(cls) -> List[HardwareInformation]:
+        data = await client().call_api(
+            http_method=HTTPMethod.GET,
+            url="/hardware-catalog/v1/hardwares",
+            use_versioned_url=False,
+        )
+        if not isinstance(data, list):
+            raise ClassiqAPIError(f"Unexpected value: {data}")
+        return [HardwareInformation.parse_obj(info) for info in data]
+
     @classmethod
     async def call_generate_hamiltonian_task(
         cls, problem: ground_state_problem.CHEMISTRY_PROBLEMS_TYPE

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,21 @@ 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,
+    List,
+    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 +91,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 +108,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 +138,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 +204,7 @@ class Client:
         try:
             detail = response.json()["detail"]
             message += f": {detail}"
-        except Exception:  # nosec B110
+        except Exception:  # noqa: S110
             pass
         raise ClassiqAPIError(message)
 
@@ -206,7 +224,7 @@ class Client:
         params: Optional[Dict] = None,
         use_versioned_url: bool = True,
         headers: Optional[Dict[str, str]] = None,
-    ) -> Union[Dict, str]:
+    ) -> Union[Dict, List, str]:
         if use_versioned_url:
             url = self.make_versioned_url(url)
         async with self.async_client() as async_client:

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