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

classiq/_internals/api_wrapper.py

@@ -1,33 +1,39 @@
 import json
-from typing import Dict, Optional, Protocol, Type, TypeVar
+from typing import Any, Optional, Protocol, TypeVar
 
+import httpx
 import pydantic
 
 import classiq.interface.executor.execution_result
 import classiq.interface.pyomo_extension
 from classiq.interface.analyzer import analysis_params, result as analysis_result
 from classiq.interface.analyzer.analysis_params import AnalysisRBParams
+from classiq.interface.analyzer.result import GraphStatus
 from classiq.interface.chemistry import ground_state_problem, operator
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqAPIError, ClassiqValueError
+from classiq.interface.execution.iqcc import (
+    IQCCInitAuthData,
+    IQCCInitAuthResponse,
+    IQCCProbeAuthData,
+    IQCCProbeAuthResponse,
+)
 from classiq.interface.execution.jobs import (
     ExecutionJobDetailsV1,
     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.model.common_model_types import ModelInput
+from classiq.interface.execution.primitives import PrimitivesInput
+from classiq.interface.executor import execution_request
+from classiq.interface.generator import quantum_program as generator_result
+from classiq.interface.hardware import HardwareInformation, Provider
+from classiq.interface.jobs import JobDescription, JobID, JSONObject
+from classiq.interface.model.model import Model
 from classiq.interface.server import routes
 
 from classiq._internals.client import client
-from classiq._internals.enum_utils import StrEnum
 from classiq._internals.jobs import JobPoller
-from classiq.exceptions import ClassiqAPIError, ClassiqValueError
 
 ResultType = TypeVar("ResultType", bound=pydantic.BaseModel)
-CLASSIQ_ACCEPT_HEADER = "X-Classiq-Accept-Version"
-
-_ACCEPT_HEADER = "X-Classiq-Accept-Version"
-_CONTENT_TYPE_HEADER = "X-Classiq-Content-Type-Version"
 
 
 class HTTPMethod(StrEnum):
@@ -35,6 +41,7 @@ class HTTPMethod(StrEnum):
     GET = "GET"
     POST = "POST"
     PATCH = "PATCH"
+    PUT = "PUT"
 
 
 class StatusType(Protocol):
@@ -43,12 +50,14 @@ class StatusType(Protocol):
 
 def _parse_job_response(
     job_result: JobDescription[JSONObject],
-    output_type: Type[ResultType],
+    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 job_result.result is not None:
+        return output_type.model_validate(job_result.result)
+    if job_result.failure_details:
+        raise ClassiqAPIError(job_result.failure_details)
+
+    raise ClassiqAPIError("Unexpected response from server")
 
 
 class ApiWrapper:
@@ -59,13 +68,18 @@ class ApiWrapper:
         url: str,
         model: pydantic.BaseModel,
         use_versioned_url: bool = True,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> dict:
         # 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())
+        body = json.loads(model.model_dump_json())
         return await cls._call_task(
-            http_method, url, body, use_versioned_url=use_versioned_url
+            http_method,
+            url,
+            body,
+            use_versioned_url=use_versioned_url,
+            http_client=http_client,
         )
 
     @classmethod
@@ -73,80 +87,121 @@ class ApiWrapper:
         cls,
         http_method: str,
         url: str,
-        body: Optional[Dict] = None,
-        params: Optional[Dict] = None,
+        body: Optional[dict] = None,
+        params: Optional[dict] = None,
         use_versioned_url: bool = True,
-        headers: Optional[Dict[str, str]] = None,
+        headers: Optional[dict[str, str]] = None,
+        allow_none: bool = False,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> dict:
-        res = await client().call_api(
+        res: Any = await client().call_api(
             http_method=http_method,
             url=url,
             body=body,
             headers=headers,
             params=params,
             use_versioned_url=use_versioned_url,
+            http_client=http_client,
         )
+        if allow_none and res is None:
+            return {}
         if not isinstance(res, dict):
             raise ClassiqValueError(f"Unexpected returned value: {res}")
         return res
 
     @classmethod
     async def call_generation_task(
-        cls, model: ModelInput
-    ) -> generator_result.GeneratedCircuit:
+        cls,
+        model: Model,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> 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)
+        result = await poller.run_pydantic(
+            model, timeout_sec=None, http_client=http_client
+        )
+        return _parse_job_response(result, generator_result.QuantumProgram)
+
+    @classmethod
+    async def call_create_execution_session(
+        cls,
+        circuit: generator_result.QuantumProgram,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> str:
+        raw_result = await cls._call_task_pydantic(
+            http_method=HTTPMethod.POST,
+            url=routes.EXECUTION_SESSIONS_PREFIX,
+            model=circuit,
+            http_client=http_client,
+        )
+        return raw_result["id"]
 
     @classmethod
-    async def call_execute_generated_circuit(
-        cls, circuit: generator_result.GeneratedCircuit
+    async def call_create_session_job(
+        cls,
+        session_id: str,
+        primitives_input: PrimitivesInput,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> execution_request.ExecutionJobDetails:
-        execution_input = await cls._call_task_pydantic(
+        data = await cls._call_task_pydantic(
+            http_method=HTTPMethod.POST,
+            url=routes.EXECUTION_SESSIONS_PREFIX + f"/{session_id}",
+            model=primitives_input,
+            http_client=http_client,
+        )
+        return execution_request.ExecutionJobDetails.model_validate(data)
+
+    @classmethod
+    async def call_convert_quantum_program(
+        cls,
+        circuit: generator_result.QuantumProgram,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> dict:
+        return await cls._call_task_pydantic(
             http_method=HTTPMethod.POST,
             url=routes.CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_FULL,
             model=circuit,
+            http_client=http_client,
         )
-        headers = {
-            _ACCEPT_HEADER: "v1",
-            _CONTENT_TYPE_HEADER: execution_input["version"],
-        }
+
+    @classmethod
+    async def call_execute_execution_input(
+        cls,
+        execution_input: dict,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> execution_request.ExecutionJobDetails:
         data = await cls._call_task(
             http_method=HTTPMethod.POST,
-            headers=headers,
-            url=routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH,
+            url=routes.EXECUTION_JOBS_FULL_PATH,
             body=execution_input,
-            use_versioned_url=False,
+            http_client=http_client,
         )
-        return execution_request.ExecutionJobDetails.parse_obj(data)
+        return execution_request.ExecutionJobDetails.model_validate(data)
 
     @classmethod
     async def call_get_execution_job_details(
         cls,
         job_id: JobID,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> execution_request.ExecutionJobDetails:
-        headers = {_CONTENT_TYPE_HEADER: "v1"}
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
-            headers=headers,
-            url=f"{routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH}/{job_id.job_id}",
-            use_versioned_url=False,
+            url=f"{routes.EXECUTION_JOBS_FULL_PATH}/{job_id.job_id}",
+            http_client=http_client,
         )
-        return execution_request.ExecutionJobDetails.parse_obj(data)
+        return execution_request.ExecutionJobDetails.model_validate(data)
 
     @classmethod
     async def call_get_execution_job_result(
         cls,
         job_id: JobID,
-        version: str,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> classiq.interface.executor.execution_result.ExecuteGeneratedCircuitResults:
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
-            url=f"{routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH}/{job_id.job_id}/result",
-            use_versioned_url=False,
-            headers={CLASSIQ_ACCEPT_HEADER: version},
+            url=f"{routes.EXECUTION_JOBS_FULL_PATH}/{job_id.job_id}/result",
+            http_client=http_client,
         )
-        return classiq.interface.executor.execution_result.ExecuteGeneratedCircuitResults.parse_obj(
+        return classiq.interface.executor.execution_result.ExecuteGeneratedCircuitResults.model_validate(
             data
         )
 
@@ -155,147 +210,238 @@ class ApiWrapper:
         cls,
         job_id: JobID,
         name: str,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> ExecutionJobDetailsV1:
         data = await cls._call_task(
             http_method=HTTPMethod.PATCH,
-            url=f"{routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH}/{job_id.job_id}",
+            url=f"{routes.EXECUTION_JOBS_FULL_PATH}/{job_id.job_id}",
             params={
                 "name": name,
             },
-            use_versioned_url=False,
+            http_client=http_client,
+        )
+        return ExecutionJobDetailsV1.model_validate(data)
+
+    @classmethod
+    async def call_cancel_execution_job(
+        cls,
+        job_id: JobID,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> None:
+        await cls._call_task(
+            http_method=HTTPMethod.PUT,
+            url=f"{routes.EXECUTION_JOBS_FULL_PATH}/{job_id.job_id}/cancel",
+            allow_none=True,
+            http_client=http_client,
         )
-        return ExecutionJobDetailsV1.parse_obj(data)
 
     @classmethod
     async def call_query_execution_jobs(
         cls,
         offset: int,
         limit: int,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> ExecutionJobsQueryResultsV1:
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
-            url=f"{routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH}",
+            url=f"{routes.EXECUTION_JOBS_FULL_PATH}",
             params={
                 "offset": offset,
                 "limit": limit,
             },
-            use_versioned_url=False,
+            http_client=http_client,
         )
-        return ExecutionJobsQueryResultsV1.parse_obj(data)
-
-    @classmethod
-    async def call_execute_estimate(
-        cls, request: execution_request.ExecutionRequest
-    ) -> execute_result.EstimationResults:
-        poller = JobPoller(base_url=routes.EXECUTE_ESTIMATE_FULL_PATH)
-        result = await poller.run_pydantic(request, timeout_sec=None)
-        return _parse_job_response(result, execute_result.EstimationResults)
-
-    @classmethod
-    async def call_execute_quantum_program(
-        cls, request: execution_request.ExecutionRequest
-    ) -> execute_result.MultipleExecutionDetails:
-        poller = JobPoller(
-            base_url=routes.EXECUTE_QUANTUM_PROGRAM_FULL_PATH,
-        )
-        result = await poller.run_pydantic(request, timeout_sec=None)
-        return _parse_job_response(result, execute_result.MultipleExecutionDetails)
+        return ExecutionJobsQueryResultsV1.model_validate(data)
 
     @classmethod
     async def call_analysis_task(
-        cls, params: analysis_params.AnalysisParams
+        cls,
+        params: analysis_params.AnalysisParams,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> analysis_result.Analysis:
         data = await cls._call_task_pydantic(
             http_method=HTTPMethod.POST,
             url=routes.ANALYZER_FULL_PATH,
             model=params,
+            http_client=http_client,
         )
 
-        return analysis_result.Analysis.parse_obj(data)
+        return analysis_result.Analysis.model_validate(data)
 
     @classmethod
     async def call_analyzer_app(
-        cls, params: generator_result.GeneratedCircuit
+        cls,
+        params: generator_result.QuantumProgram,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> analysis_result.DataID:
         data = await cls._call_task_pydantic(
             http_method=HTTPMethod.POST,
             url=routes.ANALYZER_DATA_FULL_PATH,
             model=params,
+            http_client=http_client,
         )
-        return analysis_result.DataID.parse_obj(data)
+        return analysis_result.DataID.model_validate(data)
 
     @classmethod
     async def get_generated_circuit_from_qasm(
-        cls, params: analysis_result.QasmCode
-    ) -> generator_result.GeneratedCircuit:
+        cls,
+        params: analysis_result.QasmCode,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> generator_result.QuantumProgram:
         data = await cls._call_task_pydantic(
             http_method=HTTPMethod.POST,
             url=routes.IDE_QASM_FULL_PATH,
             model=params,
+            http_client=http_client,
         )
-        return generator_result.GeneratedCircuit.parse_obj(data)
+        return generator_result.QuantumProgram.model_validate(data)
 
     @classmethod
     async def get_analyzer_app_data(
-        cls, params: analysis_result.DataID
-    ) -> generator_result.GeneratedCircuit:
+        cls,
+        params: analysis_result.DataID,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> generator_result.QuantumProgram:
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
             url=f"{routes.ANALYZER_DATA_FULL_PATH}/{params.id}",
+            http_client=http_client,
         )
-        return generator_result.GeneratedCircuit.parse_obj(data)
+        return generator_result.QuantumProgram.model_validate(data)
 
     @classmethod
     async def call_rb_analysis_task(
-        cls, params: AnalysisRBParams
+        cls,
+        params: AnalysisRBParams,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> analysis_result.RbResults:
         data = await cls._call_task(
             http_method=HTTPMethod.POST,
             url=routes.ANALYZER_RB_FULL_PATH,
-            body=params.dict(),
+            body=params.model_dump(),
+            http_client=http_client,
         )
 
-        return analysis_result.RbResults.parse_obj(data)
+        return analysis_result.RbResults.model_validate(data)
 
     @classmethod
     async def call_hardware_connectivity_task(
-        cls, params: analysis_params.AnalysisHardwareParams
+        cls,
+        params: analysis_params.AnalysisHardwareParams,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> analysis_result.GraphResult:
         data = await cls._call_task_pydantic(
             http_method=HTTPMethod.POST,
             url=routes.ANALYZER_HC_GRAPH_FULL_PATH,
             model=params,
+            http_client=http_client,
         )
-        return analysis_result.GraphResult.parse_obj(data)
+        return analysis_result.GraphResult.model_validate(data)
 
     @classmethod
     async def call_table_graphs_task(
         cls,
         params: analysis_params.AnalysisHardwareListParams,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> analysis_result.GraphResult:
         poller = JobPoller(base_url=routes.ANALYZER_HC_TABLE_GRAPH_FULL_PATH)
-        result = await poller.run_pydantic(params, timeout_sec=None)
+        result = await poller.run_pydantic(
+            params, timeout_sec=None, http_client=http_client
+        )
         return _parse_job_response(result, analysis_result.GraphResult)
 
     @classmethod
     async def call_available_devices_task(
         cls,
         params: analysis_params.AnalysisOptionalDevicesParams,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> analysis_result.DevicesResult:
-        data = await cls._call_task(
-            http_method=HTTPMethod.POST,
-            url=routes.ANALYZER_OPTIONAL_DEVICES_FULL_PATH,
-            body=params.dict(),
+        hardware_info = await cls.call_get_all_hardware_devices(http_client=http_client)
+        return cls._get_devices_from_hardware_info(hardware_info, params)
+
+    @staticmethod
+    def _get_devices_from_hardware_info(
+        hardware_info: list[HardwareInformation],
+        params: analysis_params.AnalysisOptionalDevicesParams,
+    ) -> analysis_result.DevicesResult:
+        available_hardware: dict[Provider, dict[str, bool]] = {
+            Provider.IBM_QUANTUM: {},
+            Provider.AMAZON_BRAKET: {},
+            Provider.AZURE_QUANTUM: {},
+        }
+        for info in hardware_info:
+            if info.provider not in available_hardware:
+                continue
+            is_available = info.number_of_qubits >= params.qubit_count
+            available_hardware[info.provider][info.display_name] = is_available
+        return analysis_result.DevicesResult(
+            devices=analysis_result.AvailableHardware(
+                ibm_quantum=available_hardware[Provider.IBM_QUANTUM],
+                azure_quantum=available_hardware[Provider.AZURE_QUANTUM],
+                amazon_braket=available_hardware[Provider.AMAZON_BRAKET],
+            ),
+            status=GraphStatus.SUCCESS,
         )
-        return analysis_result.DevicesResult.parse_obj(data)
+
+    @classmethod
+    async def call_get_all_hardware_devices(
+        cls,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> list[HardwareInformation]:
+        data = await client().call_api(
+            http_method=HTTPMethod.GET,
+            url="/hardware-catalog/v1/hardwares",
+            use_versioned_url=False,
+            http_client=http_client,
+        )
+        if not isinstance(data, list):
+            raise ClassiqAPIError(f"Unexpected value: {data}")
+        return [HardwareInformation.model_validate(info) for info in data]
 
     @classmethod
     async def call_generate_hamiltonian_task(
-        cls, problem: ground_state_problem.CHEMISTRY_PROBLEMS_TYPE
+        cls,
+        problem: ground_state_problem.CHEMISTRY_PROBLEMS_TYPE,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> operator.PauliOperator:
         poller = JobPoller(
             base_url=routes.GENERATE_HAMILTONIAN_FULL_PATH,
-            use_versioned_url=False,
         )
-        result = await poller.run_pydantic(problem, timeout_sec=None)
+        result = await poller.run_pydantic(
+            problem, timeout_sec=None, http_client=http_client
+        )
         return _parse_job_response(result, operator.PauliOperator)
+
+    @classmethod
+    async def call_iqcc_init_auth(
+        cls,
+        data: IQCCInitAuthData,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> IQCCInitAuthResponse:
+        response = await cls._call_task_pydantic(
+            http_method=HTTPMethod.PUT,
+            url=f"{routes.IQCC_INIT_AUTH_FULL_PATH}",
+            model=data,
+            http_client=http_client,
+        )
+        return IQCCInitAuthResponse.model_validate(response)
+
+    @classmethod
+    async def call_iqcc_probe_auth(
+        cls,
+        data: IQCCProbeAuthData,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> Optional[IQCCProbeAuthResponse]:
+        try:
+            response = await cls._call_task_pydantic(
+                http_method=HTTPMethod.PUT,
+                url=f"{routes.IQCC_PROBE_AUTH_FULL_PATH}",
+                model=data,
+                http_client=http_client,
+            )
+        except ClassiqAPIError as ex:
+            if ex.status_code == 418:
+                return None
+            raise
+
+        return IQCCProbeAuthResponse.model_validate(response)

classiq/_internals/async_utils.py

@@ -1,25 +1,18 @@
-import abc
 import asyncio
 import functools
-import inspect
 import itertools
 import logging
 import time
-import types
+from collections.abc import AsyncGenerator, Awaitable, Iterable
 from typing import (
     Any,
-    AsyncGenerator,
-    Awaitable,
     Callable,
-    Iterable,
     Optional,
     SupportsFloat,
     TypeVar,
     Union,
 )
 
-from classiq.exceptions import ClassiqValueError
-
 T = TypeVar("T")
 ASYNC_SUFFIX = "_async"
 
@@ -58,74 +51,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 +97,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 (?)