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

classiq/execution/execution_session.py

@@ -1,4 +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
@@ -15,12 +17,14 @@ from classiq.interface.executor.result import (
 from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
 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,
 )
 from classiq.execution.jobs import ExecutionJob
-from classiq.executor import execute
 from classiq.qmod.builtins import PauliTerm
 from classiq.qmod.builtins.classical_execution_primitives import (
     CARRAY_SEPARATOR,
@@ -145,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.
@@ -158,14 +163,49 @@ class ExecutionSession:
     ):
         self.program: QuantumProgram = _deserialize_program(quantum_program)
         self.update_execution_preferences(execution_preferences)
+        # When the primitives are called, we always override the
+        # classical_execution_code, and we don't want the conversion route to fail
+        # because cmain is expected in some cases
+        self.program.model.classical_execution_code = "dummy"
 
-    @property
-    def qprog(self) -> SerializedQuantumProgram:
+        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:
         """
-        Returns:
-            SerializedQuantumProgram: The serialized quantum program (str). See `QuantumProgram`.
+        Close the session and clean up its resources.
         """
-        return SerializedQuantumProgram(self.program.model_dump_json(indent=2))
+        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, self._async_client)
+        )
+
+    def _execute(
+        self, classical_execution_code: str, primitives_input: PrimitivesInput
+    ) -> ExecutionJob:
+        execution_input = self._execution_input.copy()
+        execution_input["classical_execution_code"] = classical_execution_code
+        # The use of `model_dump_json` is necessary for complex numbers serialization
+        execution_input["primitives_input"] = json.loads(
+            primitives_input.model_dump_json()
+        )
+        result = async_utils.run(
+            ApiWrapper.call_execute_execution_input(execution_input, self._async_client)
+        )
+        return ExecutionJob(details=result)
 
     def update_execution_preferences(
         self, execution_preferences: Optional[ExecutionPreferences]
@@ -193,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
@@ -210,13 +250,13 @@ class ExecutionSession:
         Returns:
             The execution job.
         """
-        self.program.model.classical_execution_code = generate_code_snippet(
+        classical_execution_code = generate_code_snippet(
             SupportedPrimitives.SAMPLE, parameters=format_parameters(parameters)
         )
-        self.program.execution_primitives_input = PrimitivesInput(
+        execution_primitives_input = PrimitivesInput(
             sample=[parse_params(parameters)] if parameters is not None else [{}]
         )
-        return execute(SerializedQuantumProgram(self.qprog))
+        return self._execute(classical_execution_code, execution_primitives_input)
 
     def batch_sample(self, parameters: list[ExecutionParams]) -> list[ExecutionDetails]:
         """
@@ -229,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:
         """
@@ -244,13 +284,13 @@ class ExecutionSession:
         Returns:
             The execution job.
         """
-        self.program.model.classical_execution_code = generate_code_snippet(
+        classical_execution_code = generate_code_snippet(
             SupportedPrimitives.BATCH_SAMPLE, parameters=format_parameters(parameters)
         )
-        self.program.execution_primitives_input = PrimitivesInput(
+        execution_primitives_input = PrimitivesInput(
             sample=[parse_params(params) for params in parameters]
         )
-        return execute(SerializedQuantumProgram(self.qprog))
+        return self._execute(classical_execution_code, execution_primitives_input)
 
     def estimate(
         self, hamiltonian: Hamiltonian, parameters: Optional[ExecutionParams] = None
@@ -266,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
@@ -284,12 +324,12 @@ class ExecutionSession:
         Returns:
             The execution job.
         """
-        self.program.model.classical_execution_code = generate_code_snippet(
+        classical_execution_code = generate_code_snippet(
             SupportedPrimitives.ESTIMATE,
             parameters=format_parameters(parameters),
             hamiltonian=to_hamiltonian_str(hamiltonian),
         )
-        self.program.execution_primitives_input = PrimitivesInput(
+        execution_primitives_input = PrimitivesInput(
             estimate=EstimateInput(
                 hamiltonian=_hamiltonian_to_pauli_operator(hamiltonian),
                 parameters=(
@@ -297,7 +337,7 @@ class ExecutionSession:
                 ),
             )
         )
-        return execute(SerializedQuantumProgram(self.qprog))
+        return self._execute(classical_execution_code, execution_primitives_input)
 
     def batch_estimate(
         self, hamiltonian: Hamiltonian, parameters: list[ExecutionParams]
@@ -313,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]
@@ -331,18 +371,18 @@ class ExecutionSession:
         Returns:
             The execution job.
         """
-        self.program.model.classical_execution_code = generate_code_snippet(
+        classical_execution_code = generate_code_snippet(
             SupportedPrimitives.BATCH_ESTIMATE,
             parameters=format_parameters(parameters),
             hamiltonian=to_hamiltonian_str(hamiltonian),
         )
-        self.program.execution_primitives_input = PrimitivesInput(
+        execution_primitives_input = PrimitivesInput(
             estimate=EstimateInput(
                 hamiltonian=_hamiltonian_to_pauli_operator(hamiltonian),
                 parameters=[parse_params(params) for params in parameters],
             )
         )
-        return execute(SerializedQuantumProgram(self.qprog))
+        return self._execute(classical_execution_code, execution_primitives_input)
 
     def estimate_cost(
         self,

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/executor.py

@@ -32,7 +32,8 @@ def _parse_serialized_qprog(
 
 async def execute_async(quantum_program: SerializedQuantumProgram) -> ExecutionJob:
     circuit = _parse_serialized_qprog(quantum_program)
-    result = await ApiWrapper.call_execute_generated_circuit(circuit)
+    execution_input = await ApiWrapper.call_convert_quantum_program(circuit)
+    result = await ApiWrapper.call_execute_execution_input(execution_input)
     return ExecutionJob(details=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.58.1'
+SEMVER_VERSION = '0.60.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/generator/arith/arithmetic_operations.py

@@ -10,6 +10,7 @@ from classiq.interface.generator.arith.machine_precision import (
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.function_params import FunctionParams
 
+IMPLICIT_OUTPUTS: Final[str] = "implicit_outputs"
 DEFAULT_GARBAGE_OUT_NAME: Final[str] = "extra_qubits"
 MODULO_WITH_FRACTION_PLACES_ERROR_MSG: Final[str] = (
     "Modulo with fraction places not supported"

classiq/interface/generator/register_role.py

@@ -29,3 +29,11 @@ class RegisterRole(StrEnum):
             RegisterRole.AUXILIARY,
             RegisterRole.EXPLICIT_ZERO_INPUT,
         }
+
+    @staticmethod
+    def clean_output_roles() -> set["RegisterRole"]:
+        return {RegisterRole.ZERO_OUTPUT, RegisterRole.AUXILIARY}
+
+    @staticmethod
+    def dirty_output_roles() -> set["RegisterRole"]:
+        return {RegisterRole.OUTPUT, RegisterRole.GARBAGE_OUTPUT}

classiq/interface/model/handle_binding.py

@@ -19,6 +19,10 @@ class HandleBinding(ASTNode):
     def __str__(self) -> str:
         return self.name
 
+    @property
+    def qmod_expr(self) -> str:
+        return self.name
+
     def is_bindable(self) -> bool:
         return True
 
@@ -57,6 +61,9 @@ class HandleBinding(ASTNode):
             return replacement
         return self
 
+    def __contains__(self, other_handle: "HandleBinding") -> bool:
+        return self.collapse() in other_handle.collapse().prefixes()
+
 
 class NestedHandleBinding(HandleBinding):
     base_handle: "ConcreteHandleBinding"
@@ -66,8 +73,8 @@ class NestedHandleBinding(HandleBinding):
     def _set_name(cls, values: Any) -> dict[str, Any]:
         if isinstance(values, dict):
             orig = values
-            while "base_handle" in values:
-                values = values["base_handle"]
+            while "base_handle" in dict(values):
+                values = dict(values)["base_handle"]
             orig["name"] = dict(values).get("name")
             return orig
         if isinstance(values, NestedHandleBinding):
@@ -106,6 +113,10 @@ class SubscriptHandleBinding(NestedHandleBinding):
     def __str__(self) -> str:
         return f"{self.base_handle}[{self.index}]"
 
+    @property
+    def qmod_expr(self) -> str:
+        return f"{self.base_handle.qmod_expr}[{self.index}]"
+
     @property
     def identifier(self) -> str:
         return f"{self.base_handle.identifier}{HANDLE_ID_SEPARATOR}{self.index}"
@@ -157,6 +168,10 @@ class SlicedHandleBinding(NestedHandleBinding):
     def __str__(self) -> str:
         return f"{self.base_handle}[{self.start}:{self.end}]"
 
+    @property
+    def qmod_expr(self) -> str:
+        return f"{self.base_handle.qmod_expr}[{self.start}:{self.end}]"
+
     @property
     def identifier(self) -> str:
         return (
@@ -165,7 +180,7 @@ class SlicedHandleBinding(NestedHandleBinding):
 
     def collapse(self) -> HandleBinding:
         if isinstance(self.base_handle, SlicedHandleBinding):
-            return SubscriptHandleBinding(
+            return SlicedHandleBinding(
                 base_handle=self.base_handle.base_handle,
                 start=self._get_collapsed_start(),
                 end=self._get_collapsed_stop(),
@@ -224,6 +239,10 @@ class FieldHandleBinding(NestedHandleBinding):
     def __str__(self) -> str:
         return f"{self.base_handle}.{self.field}"
 
+    @property
+    def qmod_expr(self) -> str:
+        return f"get_field({self.base_handle.qmod_expr}, '{self.field}')"
+
     @property
     def identifier(self) -> str:
         return f"{self.base_handle.identifier}{HANDLE_ID_SEPARATOR}{self.field}"