classiq 0.58.1__py3-none-any.whl → 0.60.0__py3-none-any.whl

classiq/_internals/api_wrapper.py

@@ -1,6 +1,7 @@
 import json
 from typing import Any, Optional, Protocol, TypeVar
 
+import httpx
 import pydantic
 
 import classiq.interface.executor.execution_result
@@ -70,13 +71,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.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
@@ -89,6 +95,7 @@ class ApiWrapper:
         use_versioned_url: bool = True,
         headers: Optional[dict[str, str]] = None,
         allow_none: bool = False,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> dict:
         res: Any = await client().call_api(
             http_method=http_method,
@@ -97,6 +104,7 @@ class ApiWrapper:
             headers=headers,
             params=params,
             use_versioned_url=use_versioned_url,
+            http_client=http_client,
         )
         if allow_none and res is None:
             return {}
@@ -106,21 +114,35 @@ class ApiWrapper:
 
     @classmethod
     async def call_generation_task(
-        cls, model: Model
+        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)
+        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_execute_generated_circuit(
-        cls, circuit: generator_result.QuantumProgram
-    ) -> execution_request.ExecutionJobDetails:
-        execution_input = await cls._call_task_pydantic(
+    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,
         )
+
+    @classmethod
+    async def call_execute_execution_input(
+        cls,
+        execution_input: dict,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> execution_request.ExecutionJobDetails:
         headers = {
             _ACCEPT_HEADER: "v1",
             _CONTENT_TYPE_HEADER: execution_input["version"],
@@ -131,6 +153,7 @@ class ApiWrapper:
             url=routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH,
             body=execution_input,
             use_versioned_url=False,
+            http_client=http_client,
         )
         return execution_request.ExecutionJobDetails.model_validate(data)
 
@@ -138,6 +161,7 @@ class ApiWrapper:
     async def call_get_execution_job_details(
         cls,
         job_id: JobID,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> execution_request.ExecutionJobDetails:
         headers = {_ACCEPT_HEADER: "v1"}
         data = await cls._call_task(
@@ -145,6 +169,7 @@ class ApiWrapper:
             headers=headers,
             url=f"{routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH}/{job_id.job_id}",
             use_versioned_url=False,
+            http_client=http_client,
         )
         return execution_request.ExecutionJobDetails.model_validate(data)
 
@@ -153,12 +178,14 @@ class ApiWrapper:
         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},
+            http_client=http_client,
         )
         return classiq.interface.executor.execution_result.ExecuteGeneratedCircuitResults.model_validate(
             data
@@ -169,6 +196,7 @@ class ApiWrapper:
         cls,
         job_id: JobID,
         name: str,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> ExecutionJobDetailsV1:
         data = await cls._call_task(
             http_method=HTTPMethod.PATCH,
@@ -177,6 +205,7 @@ class ApiWrapper:
                 "name": name,
             },
             use_versioned_url=False,
+            http_client=http_client,
         )
         return ExecutionJobDetailsV1.model_validate(data)
 
@@ -184,12 +213,14 @@ class ApiWrapper:
     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_NON_VERSIONED_FULL_PATH}/{job_id.job_id}/cancel",
             use_versioned_url=False,
             allow_none=True,
+            http_client=http_client,
         )
 
     @classmethod
@@ -197,6 +228,7 @@ class ApiWrapper:
         cls,
         offset: int,
         limit: int,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> ExecutionJobsQueryResultsV1:
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
@@ -206,73 +238,92 @@ class ApiWrapper:
                 "limit": limit,
             },
             use_versioned_url=False,
+            http_client=http_client,
         )
         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.model_validate(data)
 
     @classmethod
     async def call_analyzer_app(
-        cls, params: generator_result.QuantumProgram
+        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.model_validate(data)
 
     @classmethod
     async def get_generated_circuit_from_qasm(
-        cls, params: analysis_result.QasmCode
+        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.QuantumProgram.model_validate(data)
 
     @classmethod
     async def get_analyzer_app_data(
-        cls, params: analysis_result.DataID
+        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.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.model_dump(),
+            http_client=http_client,
         )
 
         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.model_validate(data)
 
@@ -280,17 +331,21 @@ class ApiWrapper:
     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:
-        hardware_info = await cls.call_get_all_hardware_devices()
+        hardware_info = await cls.call_get_all_hardware_devices(http_client=http_client)
         return cls._get_devices_from_hardware_info(hardware_info, params)
 
     @staticmethod
@@ -318,11 +373,15 @@ class ApiWrapper:
         )
 
     @classmethod
-    async def call_get_all_hardware_devices(cls) -> list[HardwareInformation]:
+    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}")
@@ -330,33 +389,45 @@ class ApiWrapper:
 
     @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) -> IQCCInitAuthResponse:
+    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
+        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:

classiq/_internals/client.py

@@ -1,11 +1,12 @@
 import asyncio
+import contextlib
 import functools
 import inspect
 import logging
 import os
 import platform
-import ssl
 import sys
+import time
 from collections.abc import Awaitable
 from typing import (
     Any,
@@ -148,14 +149,11 @@ class Client:
     _SESSION_HEADER = "Classiq-Session"
     _WARNINGS_HEADER = "X-Classiq-Warnings"
     _LATEST_VERSION_API_PREFIX = "/api/v1"
+    _HTTP_TIMEOUT_SECONDS = 3600  # Needs to be synced with load-balancer timeout
 
     def __init__(self, conf: config.Configuration) -> None:
         self._config = conf
         self._token_manager = token_manager.TokenManager(config=self._config)
-        self._ssl_context = ssl.create_default_context()
-        self._HTTP_TIMEOUT_SECONDS = (
-            3600  # Needs to be synced with load-balancer timeout
-        )
         self._api_prefix = self._make_api_prefix()
         self._session_id: Optional[str] = None
 
@@ -203,14 +201,44 @@ class Client:
             pass
         raise ClassiqAPIError(message, response.status_code)
 
+    @try_again_on_failure
+    async def request(
+        self,
+        http_client: httpx.AsyncClient,
+        method: str,
+        url: str,
+        json: Optional[dict] = None,
+        params: Optional[dict] = None,
+        headers: Optional[dict[str, str]] = None,
+    ) -> httpx.Response:
+        http_client.headers.update(self._get_headers())
+
+        _logger.debug("HTTP request: %s %s", method.upper(), url)
+        start_time = time.monotonic()
+        response = await http_client.request(
+            method=method,
+            url=url,
+            json=json,
+            params=params,
+            headers=headers,
+        )
+        _logger.debug(
+            "HTTP response: %s %s %d (%.0fms)",
+            method.upper(),
+            url,
+            response.status_code,
+            (time.monotonic() - start_time) * 1000,
+        )
+        self.handle_response(response)
+        return response
+
     def _make_client_args(self) -> dict[str, Any]:
         return {
             "base_url": str(self._config.host),
             "timeout": self._HTTP_TIMEOUT_SECONDS,
-            "headers": self.get_headers(),
+            "headers": self._get_headers(),
         }
 
-    @try_again_on_failure
     async def call_api(
         self,
         http_method: str,
@@ -219,20 +247,29 @@ class Client:
         params: Optional[dict] = None,
         use_versioned_url: bool = True,
         headers: Optional[dict[str, str]] = None,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> Union[dict, list, str]:
         if use_versioned_url:
             url = self.make_versioned_url(url)
-        async with self.async_client() as async_client:
-            response = await async_client.request(
+        async with self.use_client_or_create(http_client) as async_client:
+            response = await self.request(
+                http_client=async_client,
                 method=http_method,
                 url=url,
                 json=body,
                 params=params,
                 headers=headers,
             )
-            self.handle_response(response)
             return response.json()
 
+    def use_client_or_create(
+        self, http_client: Optional[httpx.AsyncClient]
+    ) -> contextlib.AbstractAsyncContextManager[httpx.AsyncClient]:
+        if http_client is None:
+            return self.async_client()
+        else:
+            return contextlib.nullcontext(enter_result=http_client)
+
     def sync_call_api(
         self,
         http_method: str,
@@ -253,7 +290,7 @@ class Client:
     def async_client(self) -> httpx.AsyncClient:
         return httpx.AsyncClient(**self._make_client_args())
 
-    def get_headers(self) -> Headers:
+    def _get_headers(self) -> Headers:
         headers = dict()
         access_token = self._token_manager.get_access_token()
         if access_token is not None:

classiq/_internals/jobs.py

@@ -10,7 +10,7 @@ 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
 
 _URL_PATH_SEP = "/"
@@ -45,19 +45,17 @@ def _general_job_description_parser(
 
 
 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,
     ) -> None:
-        self._required_headers = required_headers or set()
         self._additional_headers = additional_headers
         client_instance = client()
         self._base_url = (
@@ -65,7 +63,6 @@ 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:
@@ -78,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
@@ -116,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(
@@ -138,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 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)
+        return await self.run(body, timeout_sec, http_client=http_client)