classiq 0.59.0__py3-none-any.whl → 0.60.1__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,25 +114,34 @@ 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_convert_quantum_program(
-        cls, circuit: generator_result.QuantumProgram
+        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
+        cls,
+        execution_input: dict,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> execution_request.ExecutionJobDetails:
         headers = {
             _ACCEPT_HEADER: "v1",
@@ -136,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)
 
@@ -143,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(
@@ -150,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)
 
@@ -158,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
@@ -174,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,
@@ -182,6 +205,7 @@ class ApiWrapper:
                 "name": name,
             },
             use_versioned_url=False,
+            http_client=http_client,
         )
         return ExecutionJobDetailsV1.model_validate(data)
 
@@ -189,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
@@ -202,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,
@@ -211,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)
 
@@ -285,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
@@ -323,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}")
@@ -335,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,12 +1,14 @@
 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 types import TracebackType
 from typing import (
     Any,
     Callable,
@@ -143,19 +145,37 @@ def try_again_on_failure(
     return wrapper
 
 
+class _AsyncNullContext(contextlib.AbstractAsyncContextManager):
+    """
+    This class is meant to replace `contextlib.nullcontext`, which hadn't supported
+    async context manager until python 3.10.
+    """
+
+    def __init__(self, enter_result: Any = None) -> None:
+        self._enter_result = enter_result
+
+    async def __aenter__(self) -> Any:
+        return self._enter_result
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        pass
+
+
 class Client:
     _UNKNOWN_VERSION = HostChecker._UNKNOWN_VERSION
     _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 +223,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 +269,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 _AsyncNullContext(enter_result=http_client)
+
     def sync_call_api(
         self,
         http_method: str,
@@ -253,7 +312,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 = "/"
@@ -53,11 +53,9 @@ class JobPoller:
     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,29 +75,27 @@ 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:
@@ -114,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(
@@ -136,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)

classiq/execution/execution_session.py

@@ -1,5 +1,6 @@
 import json
 from functools import cached_property
+from types import TracebackType
 from typing import Any, Callable, Optional, Union, cast
 
 import numpy as np
@@ -18,6 +19,7 @@ from classiq.interface.generator.quantum_program import QuantumProgram
 
 from classiq._internals import async_utils
 from classiq._internals.api_wrapper import ApiWrapper
+from classiq._internals.client import client
 from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import (
     _pauli_dict_to_pauli_terms,
     _pauli_terms_to_qmod,
@@ -147,6 +149,7 @@ class ExecutionSession:
     """
     A session for executing a quantum program.
     `ExecutionSession` allows to execute the quantum program with different parameters and operations without the need to re-synthesize the model.
+    The session must be closed in order to ensure resources are properly cleaned up. It's recommended to use `ExecutionSession` as a context manager for this purpose. Alternatively, you can directly use the `close` method.
 
     Attributes:
         quantum_program (Union[SerializedQuantumProgram, QuantumProgram]): The quantum program to execute.
@@ -165,9 +168,30 @@ class ExecutionSession:
         # because cmain is expected in some cases
         self.program.model.classical_execution_code = "dummy"
 
+        self._async_client = client().async_client()
+
+    def __enter__(self) -> "ExecutionSession":
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        self.close()
+
+    def close(self) -> None:
+        """
+        Close the session and clean up its resources.
+        """
+        async_utils.run(self._async_client.aclose())
+
     @cached_property
     def _execution_input(self) -> dict:
-        return async_utils.run(ApiWrapper.call_convert_quantum_program(self.program))
+        return async_utils.run(
+            ApiWrapper.call_convert_quantum_program(self.program, self._async_client)
+        )
 
     def _execute(
         self, classical_execution_code: str, primitives_input: PrimitivesInput
@@ -179,7 +203,7 @@ class ExecutionSession:
             primitives_input.model_dump_json()
         )
         result = async_utils.run(
-            ApiWrapper.call_execute_execution_input(execution_input)
+            ApiWrapper.call_execute_execution_input(execution_input, self._async_client)
         )
         return ExecutionJob(details=result)
 
@@ -209,7 +233,7 @@ class ExecutionSession:
             The result of the sampling.
         """
         job = self.submit_sample(parameters=parameters)
-        return job.get_sample_result()
+        return job.get_sample_result(_http_client=self._async_client)
 
     def submit_sample(
         self, parameters: Optional[ExecutionParams] = None
@@ -245,7 +269,7 @@ class ExecutionSession:
             List[ExecutionDetails]: The results of all the sampling iterations.
         """
         job = self.submit_batch_sample(parameters=parameters)
-        return job.get_batch_sample_result()
+        return job.get_batch_sample_result(_http_client=self._async_client)
 
     def submit_batch_sample(self, parameters: list[ExecutionParams]) -> ExecutionJob:
         """
@@ -282,7 +306,7 @@ class ExecutionSession:
             EstimationResult: The result of the estimation.
         """
         job = self.submit_estimate(hamiltonian=hamiltonian, parameters=parameters)
-        return job.get_estimate_result()
+        return job.get_estimate_result(_http_client=self._async_client)
 
     def submit_estimate(
         self, hamiltonian: Hamiltonian, parameters: Optional[ExecutionParams] = None
@@ -329,7 +353,7 @@ class ExecutionSession:
             List[EstimationResult]: The results of all the estimation iterations.
         """
         job = self.submit_batch_estimate(hamiltonian=hamiltonian, parameters=parameters)
-        return job.get_batch_estimate_result()
+        return job.get_batch_estimate_result(_http_client=self._async_client)
 
     def submit_batch_estimate(
         self, hamiltonian: Hamiltonian, parameters: list[ExecutionParams]

classiq/execution/jobs.py

@@ -3,6 +3,8 @@ from datetime import datetime
 from typing import Any, Optional, Union
 from urllib.parse import urljoin
 
+import httpx
+
 from classiq.interface.exceptions import (
     ClassiqAPIError,
     ClassiqError,
@@ -100,22 +102,28 @@ class ExecutionJob:
         return f"{self._details.cost.total_cost} {self._details.cost.currency_code}"
 
     @classmethod
-    async def from_id_async(cls, id: str) -> "ExecutionJob":
-        details = await ApiWrapper.call_get_execution_job_details(JobID(job_id=id))
+    async def from_id_async(
+        cls,
+        id: str,
+        _http_client: Optional[httpx.AsyncClient] = None,
+    ) -> "ExecutionJob":
+        details = await ApiWrapper.call_get_execution_job_details(
+            JobID(job_id=id), http_client=_http_client
+        )
         return cls(details)
 
-    @classmethod
-    def from_id(cls, id: str) -> "ExecutionJob":
-        return syncify_function(cls.from_id_async)(id)
+    from_id = syncify_function(from_id_async)
 
     @property
     def _job_id(self) -> JobID:
         return JobID(job_id=self.id)
 
     async def result_async(
-        self, timeout_sec: Optional[float] = None
+        self,
+        timeout_sec: Optional[float] = None,
+        _http_client: Optional[httpx.AsyncClient] = None,
     ) -> ResultsCollection:
-        await self.poll_async(timeout_sec=timeout_sec)
+        await self.poll_async(timeout_sec=timeout_sec, _http_client=_http_client)
 
         if self.status == JobStatus.FAILED:
             raise ClassiqAPIError(self.error or "")
@@ -125,7 +133,9 @@ class ExecutionJob:
         if self._result is None:
             self._result = (
                 await ApiWrapper.call_get_execution_job_result(
-                    job_id=self._job_id, version=_JOB_RESULT_VERSION
+                    job_id=self._job_id,
+                    version=_JOB_RESULT_VERSION,
+                    http_client=_http_client,
                 )
             ).results
         return self._result
@@ -135,7 +145,9 @@ class ExecutionJob:
     def result_value(self, *args: Any, **kwargs: Any) -> Any:
         return self.result(*args, **kwargs)[0].value
 
-    def get_sample_result(self) -> ExecutionDetails:
+    def get_sample_result(
+        self, _http_client: Optional[httpx.AsyncClient] = None
+    ) -> ExecutionDetails:
         """
         Returns the job's result as a single sample result after validation. If the result is not yet available, waits for it.
 
@@ -146,7 +158,7 @@ class ExecutionJob:
             ClassiqExecutionResultError: In case the result does not contain a single sample result.
             ClassiqAPIError: In case the job has failed.
         """
-        results = self.result()
+        results = self.result(_http_client=_http_client)
         if len(results) != 1:
             raise ClassiqExecutionResultError("sample")
 
@@ -157,7 +169,9 @@ class ExecutionJob:
             return result.details[0]
         raise ClassiqExecutionResultError("sample")
 
-    def get_batch_sample_result(self) -> list[ExecutionDetails]:
+    def get_batch_sample_result(
+        self, _http_client: Optional[httpx.AsyncClient] = None
+    ) -> list[ExecutionDetails]:
         """
         Returns the job's result as a single batch_sample result after validation. If the result is not yet available, waits for it.
 
@@ -168,7 +182,7 @@ class ExecutionJob:
             ClassiqExecutionResultError: In case the result does not contain a single batch_sample result.
             ClassiqAPIError: In case the job has failed.
         """
-        results = self.result()
+        results = self.result(_http_client=_http_client)
         if len(results) != 1:
             raise ClassiqExecutionResultError("batch_sample")
 
@@ -180,7 +194,9 @@ class ExecutionJob:
 
         raise ClassiqExecutionResultError("batch_sample")
 
-    def get_estimate_result(self) -> EstimationResult:
+    def get_estimate_result(
+        self, _http_client: Optional[httpx.AsyncClient] = None
+    ) -> EstimationResult:
         """
         Returns the job's result as a single estimate result after validation. If the result is not yet available, waits for it.
 
@@ -191,7 +207,7 @@ class ExecutionJob:
             ClassiqExecutionResultError: In case the result does not contain a single estimate result.
             ClassiqAPIError: In case the job has failed.
         """
-        results = self.result()
+        results = self.result(_http_client=_http_client)
         if len(results) != 1:
             raise ClassiqExecutionResultError("estimate")
 
@@ -202,7 +218,9 @@ class ExecutionJob:
             return result.results[0]
         raise ClassiqExecutionResultError("estimate")
 
-    def get_batch_estimate_result(self) -> list[EstimationResult]:
+    def get_batch_estimate_result(
+        self, _http_client: Optional[httpx.AsyncClient] = None
+    ) -> list[EstimationResult]:
         """
         Returns the job's result as a single batch_estimate result after validation. If the result is not yet available, waits for it.
 
@@ -213,7 +231,7 @@ class ExecutionJob:
             ClassiqExecutionResultError: In case the result does not contain a single batch_estimate result.
             ClassiqAPIError: In case the job has failed.
         """
-        results = self.result()
+        results = self.result(_http_client=_http_client)
         if len(results) != 1:
             raise ClassiqExecutionResultError("batch_estimate")
 
@@ -225,13 +243,21 @@ class ExecutionJob:
 
         raise ClassiqExecutionResultError("batch_estimate")
 
-    async def poll_async(self, timeout_sec: Optional[float] = None) -> None:
+    async def poll_async(
+        self,
+        timeout_sec: Optional[float] = None,
+        _http_client: Optional[httpx.AsyncClient] = None,
+    ) -> None:
         if not self.status.is_final():
-            await self._poll_job(timeout_sec=timeout_sec)
+            await self._poll_job(timeout_sec=timeout_sec, _http_client=_http_client)
 
     poll = syncify_function(poll_async)
 
-    async def _poll_job(self, timeout_sec: Optional[float] = None) -> None:
+    async def _poll_job(
+        self,
+        timeout_sec: Optional[float] = None,
+        _http_client: Optional[httpx.AsyncClient] = None,
+    ) -> None:
         def response_parser(json_response: JSONObject) -> Optional[bool]:
             self._details = ExecutionJobDetails.model_validate(json_response)
             if self.status.is_final():
@@ -247,14 +273,26 @@ class ExecutionJob:
             job_id=self._job_id,
             response_parser=response_parser,
             timeout_sec=timeout_sec,
+            http_client=_http_client,
         )
 
-    async def rename_async(self, name: str) -> None:
-        self._details = await ApiWrapper.call_patch_execution_job(self._job_id, name)
+    async def rename_async(
+        self,
+        name: str,
+        _http_client: Optional[httpx.AsyncClient] = None,
+    ) -> None:
+        self._details = await ApiWrapper.call_patch_execution_job(
+            self._job_id,
+            name,
+            http_client=_http_client,
+        )
 
     rename = syncify_function(rename_async)
 
-    async def cancel_async(self) -> None:
+    async def cancel_async(
+        self,
+        _http_client: Optional[httpx.AsyncClient] = None,
+    ) -> None:
         """
         Cancels the execution job. This implies the cancellation of any ongoing jobs
         sent to the provider during this execution job.
@@ -263,7 +301,10 @@ class ExecutionJob:
         to continue polling the job in order to ensure its cancellation, which might
         not be immediate.
         """
-        await ApiWrapper.call_cancel_execution_job(self._job_id)
+        await ApiWrapper.call_cancel_execution_job(
+            self._job_id,
+            http_client=_http_client,
+        )
 
     cancel = syncify_function(cancel_async)
 

classiq/execution/qaoa.py

@@ -65,20 +65,22 @@ def execute_qaoa(
     model = create_model(main)
     qprog = synthesize(model)
 
-    es = ExecutionSession(qprog, execution_preferences)
-    initial_params = (
-        np.concatenate((np.linspace(0, 1, num_layers), np.linspace(1, 0, num_layers)))
-        * math.pi
-    )
-    final_params = scipy.optimize.minimize(
-        lambda params: es.estimate_cost(
-            lambda state: cost_func(state["v"]),
-            {"params": params.tolist()},
-        ),
-        x0=initial_params,
-        method="COBYLA",
-        options={"maxiter": maxiter},
-    ).x.tolist()
-    result = es.sample({"params": final_params})
+    with ExecutionSession(qprog, execution_preferences) as es:
+        initial_params = (
+            np.concatenate(
+                (np.linspace(0, 1, num_layers), np.linspace(1, 0, num_layers))
+            )
+            * math.pi
+        )
+        final_params = scipy.optimize.minimize(
+            lambda params: es.estimate_cost(
+                lambda state: cost_func(state["v"]),
+                {"params": params.tolist()},
+            ),
+            x0=initial_params,
+            method="COBYLA",
+            options={"maxiter": maxiter},
+        ).x.tolist()
+        result = es.sample({"params": final_params})
 
     return model, qprog, result

classiq/execution/qnn.py

@@ -59,22 +59,21 @@ def execute_qnn(
     arguments: MultipleArguments,
     observable: Optional[PauliOperator] = None,
 ) -> ResultsCollection:
-    session = ExecutionSession(quantum_program)
+    with ExecutionSession(quantum_program) as session:
+        if observable:
+            execute_function = functools.partial(
+                _execute_qnn_estimate,
+                session=session,
+                observable=observable,
+            )
+        else:
+            execute_function = functools.partial(
+                _execute_qnn_sample,
+                session=session,
+            )
 
-    if observable:
-        execute_function = functools.partial(
-            _execute_qnn_estimate,
-            session=session,
-            observable=observable,
-        )
-    else:
-        execute_function = functools.partial(
-            _execute_qnn_sample,
-            session=session,
-        )
-
-    result: ResultsCollection = []
-    for chunk in more_itertools.chunked(arguments, _MAX_ARGUMENTS_SIZE):
-        chunk_result = execute_function(arguments=chunk)
-        result.extend(chunk_result)
-    return result
+        result: ResultsCollection = []
+        for chunk in more_itertools.chunked(arguments, _MAX_ARGUMENTS_SIZE):
+            chunk_result = execute_function(arguments=chunk)
+            result.extend(chunk_result)
+        return result

classiq/interface/_version.py

@@ -3,5 +3,5 @@ from packaging.version import Version
 # This file was generated automatically
 # Please don't track in version control (DONTTRACK)
 
-SEMVER_VERSION = '0.59.0'
+SEMVER_VERSION = '0.60.1'
 VERSION = str(Version(SEMVER_VERSION))

{classiq-0.59.0.dist-info → classiq-0.60.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: classiq
-Version: 0.59.0
+Version: 0.60.1
 Summary: Classiq's Python SDK for quantum computing
 Home-page: https://classiq.io
 License: Proprietary

{classiq-0.59.0.dist-info → classiq-0.60.1.dist-info}/RECORD

@@ -3,7 +3,7 @@ classiq/_analyzer_extras/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 classiq/_analyzer_extras/_ipywidgets_async_extension.py,sha256=7zv7mANDaLHH8QRGyY9QGDPPKPTjKKYdoq22iJaq_Ns,2190
 classiq/_analyzer_extras/interactive_hardware.py,sha256=f7ad2HeFq1f-2dJtPpgOE_w2IFzm49W6P_c-MzqJ5qE,3257
 classiq/_internals/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-classiq/_internals/api_wrapper.py,sha256=CtrQPjCoDtGOJXMmROifX-YcYE6MkQyqJtB2DRwAu2U,12923
+classiq/_internals/api_wrapper.py,sha256=RmaC6gCinBwQat0kff66T1GW6Kf55IwOQgBwxN01nWc,15198
 classiq/_internals/async_utils.py,sha256=utfzFLuCqmvxTLgg3JhMi-sBMIQFVW2LU5dqUEAJLCM,3370
 classiq/_internals/authentication/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 classiq/_internals/authentication/auth0.py,sha256=K6yCnDUhIfgx-GfUHivak88_u06USHjXAjx9b3m5iek,3663
@@ -11,11 +11,11 @@ classiq/_internals/authentication/authentication.py,sha256=58Xv1QtynXwEfBqIV5E3L
 classiq/_internals/authentication/device.py,sha256=dUii1-Z26j0NY4R6J4p0gjYSq5Goj-gwMxXPSnVANuE,4024
 classiq/_internals/authentication/password_manager.py,sha256=aVR3wt07EJNa1OcUOmM9Nyg9Y4w8-3XzzrxJNsBWUBM,4438
 classiq/_internals/authentication/token_manager.py,sha256=XStkqCPUQEqc3uj6tt_XzfUIcUlyT-94tBZ8tpQIy_s,5280
-classiq/_internals/client.py,sha256=V-hyLXLW2EgE9mPOOemlEDSfz9SgXxez0aYmlv5UaU0,10412
+classiq/_internals/client.py,sha256=WbIzf9jliAa-JssNTeEsFHm9K6DBXkD6ojocN-HVjGs,12218
 classiq/_internals/config.py,sha256=-UKKvPp_61sxXY-URqU1feLqlfh9ww4wCDH4yl14EiA,3534
 classiq/_internals/help.py,sha256=9gl64Y8nKW-f-8pYt7lMozOP6uERcIIf8dotgn_WKA0,460
 classiq/_internals/host_checker.py,sha256=D0rgnoZrHo62rYS32yCuYZSyMrMChZG5ITsJxwj0R5g,3969
-classiq/_internals/jobs.py,sha256=s-1-500Q-KrVG9nnTPbxcNfVqWiEfRnVKDL8A8HWnKM,6295
+classiq/_internals/jobs.py,sha256=Wu8FvnhqAjLghBhfrCOHj0cMSH7LV39gI-6Iit_TWOc,6329
 classiq/_internals/logger.py,sha256=TGV37AR6aezLUzKUz4V1JercHeC68o_nNMlIRNHSRFM,634
 classiq/_internals/type_validation.py,sha256=kRd6td9krHPSZWgfclNsQcX7sNTqikp5wc3DvNbDsrA,1332
 classiq/analyzer/__init__.py,sha256=1ASEd3a5BLznMq_uD4ogR6buanALXfJIONZYmCweAgA,186
@@ -88,14 +88,14 @@ classiq/applications/qsvm/qsvm_data_generation.py,sha256=BIXBAxYNAvwZi1pVQJeSPTa
 classiq/applications/qsvm/qsvm_model_constructor.py,sha256=4Md7FuKZsG9FUCwBVDwkLic2_EtYCfYCkT0mnH-IsVQ,3945
 classiq/execution/__init__.py,sha256=t43kgz7GlyB8WT4gY10kr6tBBCTsD95oSWy-AZZZF_8,1220
 classiq/execution/all_hardware_devices.py,sha256=KpLefEISE03FDdgFPGggXeG7NAxBW4090gN4272Dl-E,368
-classiq/execution/execution_session.py,sha256=1ZItrjCn5lRdpQfPXGndzWrE_zpg1xY_-AVdhCMsfsU,16628
+classiq/execution/execution_session.py,sha256=LICEO4UcRg0QN-g3gvXxA1IjitaqNy8bUGTAsjZIDwo,17598
 classiq/execution/iqcc.py,sha256=0wy1tgQFcwqf9wFYyi6_OYRtx4s0AEViIAIvUkyKBmk,2429
-classiq/execution/jobs.py,sha256=XCxv2oLF-0XyXmWS5DutuHhvLrmg5thc0j4yBSdvX3Q,9880
-classiq/execution/qaoa.py,sha256=IiicS_L41FeR_9kDcqLKnbuBuWj5ABuuGKqyC6SVsHk,3007
-classiq/execution/qnn.py,sha256=6lAKO0TpSEkcY_EwbJfVqNeqCeOegmkBQC1AzUrWxy0,2333
+classiq/execution/jobs.py,sha256=d8GxbMgnvsqVFgTl6ZZzE0pLiXMLBp_lytk-XoWN31k,10980
+classiq/execution/qaoa.py,sha256=P2lrUaZrNM9wrkK0wLybwO6tbYi_WVLPAN9p6w5-5Tc,3100
+classiq/execution/qnn.py,sha256=WGPvncz5uS2WxSY3-yBWt2LFiCk6Ug8WKWF-Kp-f7TM,2403
 classiq/executor.py,sha256=rvcOI95rYtU2OSsuHLSjh9jutAk-CPSP6Bi01Fw3NqQ,2686
 classiq/interface/__init__.py,sha256=cg7hD_XVu1_jJ1fgwmT0rMIoZHopNVeB8xtlmMx-E_A,83
-classiq/interface/_version.py,sha256=rOMLK5Bd2ikoXtLbPc7cjxr3_XaPCsHMXecVZTZmeh0,197
+classiq/interface/_version.py,sha256=2Ae9frR30aMOSJn-oAr28BByDJGHJAjWfEMFbXGQLOg,197
 classiq/interface/analyzer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 classiq/interface/analyzer/analysis_params.py,sha256=dM5rwSks798cxk4FWe4_X5ToRYtgZQh34F1u0XrFkK8,3881
 classiq/interface/analyzer/cytoscape_graph.py,sha256=MpeRBIYS1TfwYwiFpgTO51IE0KoxhY510pmEM3S0rbw,2361
@@ -510,6 +510,6 @@ classiq/qmod/type_attribute_remover.py,sha256=NZmTXAsngWqthXjE8n-n6yE72fiWTFM12-
 classiq/qmod/utilities.py,sha256=z_VnIRmOYTWjJp2UlOcWK0rQRtMqysmP_Gr6WYY_nak,2734
 classiq/qmod/write_qmod.py,sha256=Oo-j_rSfcmzC5MOn0Vq334vv_OTvdD4P7K9pv-gbo8c,1833
 classiq/synthesis.py,sha256=WLk3wpX_xPiAMstF9PGMO5SWVb_qqa1sN2Nj3MekX34,8113
-classiq-0.59.0.dist-info/METADATA,sha256=nNs_shmuDS6cAFEx9HamByF3V4eWV25bemBS3yh56Mo,3459
-classiq-0.59.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-classiq-0.59.0.dist-info/RECORD,,
+classiq-0.60.1.dist-info/METADATA,sha256=FQ0H8VWQncpnZcXnCQkVRFqlgq5DtajZCQYQ_VJTNPQ,3459
+classiq-0.60.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+classiq-0.60.1.dist-info/RECORD,,