classiq 0.46.1__py3-none-any.whl → 0.48.0__py3-none-any.whl

classiq/_internals/api_wrapper.py

@@ -1,5 +1,5 @@
 import json
-from typing import Dict, List, Optional, Protocol, Type, TypeVar
+from typing import Any, Dict, List, Optional, Protocol, Type, TypeVar
 
 import pydantic
 
@@ -7,6 +7,7 @@ import classiq.interface.executor.execution_result
 import classiq.interface.pyomo_extension
 from classiq.interface.analyzer import analysis_params, result as analysis_result
 from classiq.interface.analyzer.analysis_params import AnalysisRBParams
+from classiq.interface.analyzer.result import GraphStatus
 from classiq.interface.chemistry import ground_state_problem, operator
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.exceptions import ClassiqAPIError, ClassiqValueError
@@ -16,7 +17,7 @@ from classiq.interface.execution.jobs import (
 )
 from classiq.interface.executor import execution_request
 from classiq.interface.generator import quantum_program as generator_result
-from classiq.interface.hardware import HardwareInformation
+from classiq.interface.hardware import HardwareInformation, Provider
 from classiq.interface.jobs import JobDescription, JobID, JSONObject
 from classiq.interface.model.model import Model
 from classiq.interface.server import routes
@@ -36,6 +37,7 @@ class HTTPMethod(StrEnum):
     GET = "GET"
     POST = "POST"
     PATCH = "PATCH"
+    PUT = "PUT"
 
 
 class StatusType(Protocol):
@@ -80,8 +82,9 @@ class ApiWrapper:
         params: Optional[Dict] = None,
         use_versioned_url: bool = True,
         headers: Optional[Dict[str, str]] = None,
+        allow_none: bool = False,
     ) -> dict:
-        res = await client().call_api(
+        res: Any = await client().call_api(
             http_method=http_method,
             url=url,
             body=body,
@@ -89,6 +92,8 @@ class ApiWrapper:
             params=params,
             use_versioned_url=use_versioned_url,
         )
+        if allow_none and res is None:
+            return {}
         if not isinstance(res, dict):
             raise ClassiqValueError(f"Unexpected returned value: {res}")
         return res
@@ -169,6 +174,18 @@ class ApiWrapper:
         )
         return ExecutionJobDetailsV1.parse_obj(data)
 
+    @classmethod
+    async def call_cancel_execution_job(
+        cls,
+        job_id: JobID,
+    ) -> 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,
+        )
+
     @classmethod
     async def call_query_execution_jobs(
         cls,
@@ -267,12 +284,32 @@ class ApiWrapper:
         cls,
         params: analysis_params.AnalysisOptionalDevicesParams,
     ) -> analysis_result.DevicesResult:
-        data = await cls._call_task(
-            http_method=HTTPMethod.POST,
-            url=routes.ANALYZER_OPTIONAL_DEVICES_FULL_PATH,
-            body=params.dict(),
+        hardware_info = await cls.call_get_all_hardware_devices()
+        return cls._get_devices_from_hardware_info(hardware_info, params)
+
+    @staticmethod
+    def _get_devices_from_hardware_info(
+        hardware_info: List[HardwareInformation],
+        params: analysis_params.AnalysisOptionalDevicesParams,
+    ) -> analysis_result.DevicesResult:
+        available_hardware: Dict[Provider, Dict[str, bool]] = {
+            Provider.IBM_QUANTUM: {},
+            Provider.AMAZON_BRAKET: {},
+            Provider.AZURE_QUANTUM: {},
+        }
+        for info in hardware_info:
+            if info.provider not in available_hardware:
+                continue
+            is_available = info.number_of_qubits >= params.qubit_count
+            available_hardware[info.provider][info.display_name] = is_available
+        return analysis_result.DevicesResult(
+            devices=analysis_result.AvailableHardware(
+                ibm_quantum=available_hardware[Provider.IBM_QUANTUM],
+                azure_quantum=available_hardware[Provider.AZURE_QUANTUM],
+                amazon_braket=available_hardware[Provider.AMAZON_BRAKET],
+            ),
+            status=GraphStatus.SUCCESS,
         )
-        return analysis_result.DevicesResult.parse_obj(data)
 
     @classmethod
     async def call_get_all_hardware_devices(cls) -> List[HardwareInformation]:

classiq/applications/combinatorial_helpers/pauli_helpers/pauli_utils.py

@@ -44,10 +44,5 @@ def _pauli_terms_to_qmod(hamiltonian: List[PauliTerm]) -> str:
     return ", ".join(qmod_strings)
 
 
-def _pauli_dict_to_str(hamiltonian: List[QmodPyStruct]) -> str:
-    res = []
-    for struct in hamiltonian:
-        pauli_str = ", ".join([pauli_enum_to_str(p) for p in struct["pauli"]])
-        res.append(f'"pauli": [{pauli_str}], "coefficient": {struct["coefficient"]}')
-
-    return f"{{{', '.join(res)}}}"
+def _pauli_dict_to_pauli_terms(hamiltonian: List[QmodPyStruct]) -> List[PauliTerm]:
+    return [PauliTerm(**struct) for struct in hamiltonian]

classiq/applications/grover/grover_model_constructor.py

@@ -11,6 +11,7 @@ from classiq.interface.model.native_function_definition import NativeFunctionDef
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
+    ArithmeticOperationKind,
 )
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
@@ -110,7 +111,7 @@ def construct_grover_model(
                     ArithmeticOperation(
                         expression=Expression(expr=expression),
                         result_var=HandleBinding(name="res"),
-                        inplace_result=True,
+                        operation_kind=ArithmeticOperationKind.InplaceXor,
                     ),
                 ],
             ),

classiq/execution/execution_session.py

@@ -1,22 +1,22 @@
 import json
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union, cast
 
+from classiq.interface.chemistry.operator import PauliOperator, pauli_integers_to_str
 from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.execution.primitives import EstimateInput, PrimitivesInput
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
-from classiq.interface.executor.execution_result import ResultsCollection
 from classiq.interface.executor.result import (
     EstimationResult,
-    EstimationResults,
     ExecutionDetails,
-    MultipleExecutionDetails,
 )
 from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
 from classiq.interface.generator.quantum_program import QuantumProgram
 
 from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import (
-    _pauli_dict_to_str,
+    _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 (
@@ -52,12 +52,26 @@ def _deserialize_program(program: Program) -> QuantumProgram:
     )
 
 
+def hamiltonian_to_pauli_terms(hamiltonian: Hamiltonian) -> List[PauliTerm]:
+    if isinstance(hamiltonian[0], PauliTerm):
+        return cast(List[PauliTerm], hamiltonian)
+    else:
+        return _pauli_dict_to_pauli_terms(cast(List[QmodPyStruct], hamiltonian))
+
+
 def to_hamiltonian_str(hamiltonian: Hamiltonian) -> str:
-    return (
-        _pauli_terms_to_qmod(cast(List[PauliTerm], hamiltonian))
-        if isinstance(hamiltonian[0], PauliTerm)
-        else _pauli_dict_to_str(cast(List[QmodPyStruct], hamiltonian))
-    )
+    return _pauli_terms_to_qmod(hamiltonian_to_pauli_terms(hamiltonian))
+
+
+def _hamiltonian_to_pauli_operator(hamiltonian: Hamiltonian) -> PauliOperator:
+    pauli_list = [
+        (
+            pauli_integers_to_str(elem.pauli),  # type: ignore[arg-type]
+            elem.coefficient,
+        )
+        for elem in hamiltonian_to_pauli_terms(hamiltonian)
+    ]
+    return PauliOperator(pauli_list=pauli_list)
 
 
 def serialize(
@@ -165,14 +179,6 @@ class ExecutionSession:
         if execution_preferences is not None:
             self.program.model.execution_preferences = execution_preferences
 
-    def _execute_quantum_program(
-        self, operation: str, **kwargs: Any
-    ) -> ResultsCollection:
-        self.program.model.classical_execution_code = generate_code_snippet(
-            operation, **kwargs
-        )
-        return execute(SerializedQuantumProgram(self.qprog)).result()
-
     def sample(self, parameters: Optional[ExecutionParams] = None) -> ExecutionDetails:
         """
         Samples the quantum program with the given parameters, if any.
@@ -180,16 +186,34 @@ class ExecutionSession:
         Args:
             parameters: The values to set for the parameters of the quantum program when sampling. Each key should be the name of a parameter in the quantum program (parameters of the main function), and the value should be the value to set for that parameter.
 
+        Returns:
+            The result of the sampling.
+        """
+        job = self.submit_sample(parameters=parameters)
+        return job.get_sample_result()
+
+    def submit_sample(
+        self, parameters: Optional[ExecutionParams] = None
+    ) -> ExecutionJob:
+        """
+        Initiates an execution job with the `sample` primitive.
+
+        This is a non-blocking version of `sample`: it gets the same parameters and initiates the same execution job, but instead
+        of waiting for the result, it returns the job object immediately.
+
+        Args:
+            parameters: The values to set for the parameters of the quantum program when sampling. Each key should be the name of a parameter in the quantum program (parameters of the main function), and the value should be the value to set for that parameter.
 
         Returns:
-            ExecutionDetails: The result of the sampling.
+            The execution job.
         """
-        return cast(
-            ExecutionDetails,
-            self._execute_quantum_program(
-                SupportedPrimitives.SAMPLE, parameters=format_parameters(parameters)
-            )[0].value,
+        self.program.model.classical_execution_code = generate_code_snippet(
+            SupportedPrimitives.SAMPLE, parameters=format_parameters(parameters)
         )
+        self.program.execution_primitives_input = PrimitivesInput(
+            sample=[parse_params(parameters)] if parameters is not None else [{}]
+        )
+        return execute(SerializedQuantumProgram(self.qprog))
 
     def batch_sample(self, parameters: List[ExecutionParams]) -> List[ExecutionDetails]:
         """
@@ -201,13 +225,29 @@ class ExecutionSession:
         Returns:
             List[ExecutionDetails]: The results of all the sampling iterations.
         """
-        return cast(
-            MultipleExecutionDetails,
-            self._execute_quantum_program(
-                SupportedPrimitives.BATCH_SAMPLE,
-                parameters=format_parameters(parameters),
-            )[0].value,
-        ).details
+        job = self.submit_batch_sample(parameters=parameters)
+        return job.get_batch_sample_result()
+
+    def submit_batch_sample(self, parameters: List[ExecutionParams]) -> ExecutionJob:
+        """
+        Initiates an execution job with the `batch_sample` primitive.
+
+        This is a non-blocking version of `batch_sample`: it gets the same parameters and initiates the same execution job, but instead
+        of waiting for the result, it returns the job object immediately.
+
+        Args:
+            parameters: A list of the parameters for each iteration. Each item is a dictionary where each key should be the name of a parameter in the quantum program (parameters of the main function), and the value should be the value to set for that parameter.
+
+        Returns:
+            The execution job.
+        """
+        self.program.model.classical_execution_code = generate_code_snippet(
+            SupportedPrimitives.BATCH_SAMPLE, parameters=format_parameters(parameters)
+        )
+        self.program.execution_primitives_input = PrimitivesInput(
+            sample=[parse_params(params) for params in parameters]
+        )
+        return execute(SerializedQuantumProgram(self.qprog))
 
     def estimate(
         self, hamiltonian: Hamiltonian, parameters: Optional[ExecutionParams] = None
@@ -222,14 +262,39 @@ class ExecutionSession:
         Returns:
             EstimationResult: The result of the estimation.
         """
-        return cast(
-            EstimationResult,
-            self._execute_quantum_program(
-                SupportedPrimitives.ESTIMATE,
-                parameters=format_parameters(parameters),
-                hamiltonian=to_hamiltonian_str(hamiltonian),
-            )[0].value,
+        job = self.submit_estimate(hamiltonian=hamiltonian, parameters=parameters)
+        return job.get_estimate_result()
+
+    def submit_estimate(
+        self, hamiltonian: Hamiltonian, parameters: Optional[ExecutionParams] = None
+    ) -> ExecutionJob:
+        """
+        Initiates an execution job with the `estimate` primitive.
+
+        This is a non-blocking version of `estimate`: it gets the same parameters and initiates the same execution job, but instead
+        of waiting for the result, it returns the job object immediately.
+
+        Args:
+            hamiltonian: The Hamiltonian to estimate the expectation value of.
+            parameters: The values to set for the parameters of the quantum program when estimating.  Each key should be the name of a parameter in the quantum program (parameters of the main function), and the value should be the value to set for that parameter.
+
+        Returns:
+            The execution job.
+        """
+        self.program.model.classical_execution_code = generate_code_snippet(
+            SupportedPrimitives.ESTIMATE,
+            parameters=format_parameters(parameters),
+            hamiltonian=to_hamiltonian_str(hamiltonian),
+        )
+        self.program.execution_primitives_input = PrimitivesInput(
+            estimate=EstimateInput(
+                hamiltonian=_hamiltonian_to_pauli_operator(hamiltonian),
+                parameters=(
+                    [parse_params(parameters)] if parameters is not None else [{}]
+                ),
+            )
         )
+        return execute(SerializedQuantumProgram(self.qprog))
 
     def batch_estimate(
         self, hamiltonian: Hamiltonian, parameters: List[ExecutionParams]
@@ -244,11 +309,34 @@ class ExecutionSession:
         Returns:
             List[EstimationResult]: The results of all the estimation iterations.
         """
-        return cast(
-            EstimationResults,
-            self._execute_quantum_program(
-                SupportedPrimitives.BATCH_ESTIMATE,
-                parameters=format_parameters(parameters),
-                hamiltonian=to_hamiltonian_str(hamiltonian),
-            )[0].value,
-        ).results
+        job = self.submit_batch_estimate(hamiltonian=hamiltonian, parameters=parameters)
+        return job.get_batch_estimate_result()
+
+    def submit_batch_estimate(
+        self, hamiltonian: Hamiltonian, parameters: List[ExecutionParams]
+    ) -> ExecutionJob:
+        """
+        Initiates an execution job with the `batch_estimate` primitive.
+
+        This is a non-blocking version of `batch_estimate`: it gets the same parameters and initiates the same execution job, but instead
+        of waiting for the result, it returns the job object immediately.
+
+        Args:
+            hamiltonian: The Hamiltonian to estimate the expectation value of.
+            parameters: A list of the parameters for each iteration. Each item is a dictionary where each key should be the name of a parameter in the quantum program (parameters of the main function), and the value should be the value to set for that parameter.
+
+        Returns:
+            The execution job.
+        """
+        self.program.model.classical_execution_code = generate_code_snippet(
+            SupportedPrimitives.BATCH_ESTIMATE,
+            parameters=format_parameters(parameters),
+            hamiltonian=to_hamiltonian_str(hamiltonian),
+        )
+        self.program.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))

classiq/execution/jobs.py

@@ -3,10 +3,19 @@ from datetime import datetime
 from typing import Any, List, Optional, Union
 from urllib.parse import urljoin
 
-from classiq.interface.exceptions import ClassiqAPIError
+from classiq.interface.exceptions import (
+    ClassiqAPIError,
+    ClassiqError,
+)
 from classiq.interface.execution.jobs import ExecutionJobDetailsV1
 from classiq.interface.executor.execution_request import ExecutionJobDetails
 from classiq.interface.executor.execution_result import ResultsCollection
+from classiq.interface.executor.result import (
+    EstimationResult,
+    EstimationResults,
+    ExecutionDetails,
+    MultipleExecutionDetails,
+)
 from classiq.interface.jobs import JobStatus, JSONObject
 from classiq.interface.server.routes import EXECUTION_JOBS_NON_VERSIONED_FULL_PATH
 
@@ -21,6 +30,13 @@ _JOB_DETAILS_VERSION = "v1"
 _JOB_RESULT_VERSION = "v1"
 
 
+class ClassiqExecutionResultError(ClassiqError):
+    def __init__(self, primitive: str) -> None:
+        super().__init__(
+            f"Execution job does not contain a single {primitive!r} result, make sure you use the 'get_*_result' method matching the primitive you executed. You can use the 'result' method to see the general result."
+        )
+
+
 class ExecutionJob:
     _details: _JobDetails
     _result: Optional[ResultsCollection]
@@ -112,6 +128,96 @@ class ExecutionJob:
     def result_value(self, *args: Any, **kwargs: Any) -> Any:
         return self.result(*args, **kwargs)[0].value
 
+    def get_sample_result(self) -> ExecutionDetails:
+        """
+        Returns the job's result as a single sample result after validation. If the result is not yet available, waits for it.
+
+        Returns:
+            The sample result of the execution job.
+
+        Raises:
+            ClassiqExecutionResultError: In case the result does not contain a single sample result.
+            ClassiqAPIError: In case the job has failed.
+        """
+        results = self.result()
+        if len(results) != 1:
+            raise ClassiqExecutionResultError("sample")
+
+        result = results[0].value
+        if isinstance(result, ExecutionDetails):
+            return result
+        if isinstance(result, MultipleExecutionDetails) and len(result.details) == 1:
+            return result.details[0]
+        raise ClassiqExecutionResultError("sample")
+
+    def get_batch_sample_result(self) -> 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.
+
+        Returns:
+            The batch_sample result of the execution job.
+
+        Raises:
+            ClassiqExecutionResultError: In case the result does not contain a single batch_sample result.
+            ClassiqAPIError: In case the job has failed.
+        """
+        results = self.result()
+        if len(results) != 1:
+            raise ClassiqExecutionResultError("batch_sample")
+
+        result = results[0].value
+        if isinstance(result, ExecutionDetails):
+            return [result]
+        if isinstance(result, MultipleExecutionDetails):
+            return result.details
+
+        raise ClassiqExecutionResultError("batch_sample")
+
+    def get_estimate_result(self) -> EstimationResult:
+        """
+        Returns the job's result as a single estimate result after validation. If the result is not yet available, waits for it.
+
+        Returns:
+            The estimate result of the execution job.
+
+        Raises:
+            ClassiqExecutionResultError: In case the result does not contain a single estimate result.
+            ClassiqAPIError: In case the job has failed.
+        """
+        results = self.result()
+        if len(results) != 1:
+            raise ClassiqExecutionResultError("estimate")
+
+        result = results[0].value
+        if isinstance(result, EstimationResult):
+            return result
+        if isinstance(result, EstimationResults) and len(result.results) == 1:
+            return result.results[0]
+        raise ClassiqExecutionResultError("estimate")
+
+    def get_batch_estimate_result(self) -> 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.
+
+        Returns:
+            The batch_estimate result of the execution job.
+
+        Raises:
+            ClassiqExecutionResultError: In case the result does not contain a single batch_estimate result.
+            ClassiqAPIError: In case the job has failed.
+        """
+        results = self.result()
+        if len(results) != 1:
+            raise ClassiqExecutionResultError("batch_estimate")
+
+        result = results[0].value
+        if isinstance(result, EstimationResult):
+            return [result]
+        if isinstance(result, EstimationResults):
+            return result.results
+
+        raise ClassiqExecutionResultError("batch_estimate")
+
     async def poll_async(self, timeout_sec: Optional[float] = None) -> None:
         if not self.status.is_final():
             await self._poll_job(timeout_sec=timeout_sec)
@@ -141,6 +247,19 @@ class ExecutionJob:
 
     rename = syncify_function(rename_async)
 
+    async def cancel_async(self) -> None:
+        """
+        Cancels the execution job. This implies the cancellation of any ongoing jobs
+        sent to the provider during this execution job.
+
+        The function returns without waiting to the actual cancellation. It is possible
+        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)
+
+    cancel = syncify_function(cancel_async)
+
     @property
     def ide_url(self) -> str:
         base_url = client().config.ide

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.46.1'
+SEMVER_VERSION = '0.48.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/backend/quantum_backend_providers.py

@@ -68,7 +68,6 @@ class AzureQuantumBackendNames(StrEnum):
     IONQ_SIMULATOR = "ionq.simulator"
     MICROSOFT_ESTIMATOR = "microsoft.estimator"
     MICROSOFT_FULLSTATE_SIMULATOR = "microsoft.simulator.fullstate"
-    RIGETTI_ASPEN3 = "rigetti.qpu.aspen-m-3"
     RIGETTI_SIMULATOR = "rigetti.sim.qvm"
     RIGETTI_ANKAA2 = "rigetti.qpu.ankaa-2"
     RIGETTI_ANKAA9 = "rigetti.qpu.ankaa-9q-1"

classiq/interface/debug_info/debug_info.py

@@ -1,5 +1,5 @@
 import json
-from typing import Any, Dict, Optional, Union
+from typing import Any, Dict, Mapping, Optional, Tuple, Union
 from uuid import UUID
 
 from pydantic import BaseModel, Field
@@ -14,10 +14,12 @@ ParameterValue = Union[float, int, str, None]
 
 class FunctionDebugInfo(BaseModel):
     name: str
+    # Parameters describe classical parameters passed to function
     # ParameterValue appears in type only for backwards compatibility
     parameters: Dict[str, str] = Field(type=Dict[str, ParameterValue])
     level: OperationLevel
     is_allocate_or_free: bool = Field(default=False)
+    port_to_passed_variable_map: Dict[str, str] = Field(default_factory=dict)
 
     @staticmethod
     def param_controller(value: Any) -> str:
@@ -26,6 +28,26 @@ class FunctionDebugInfo(BaseModel):
         except TypeError:
             return repr(value)
 
+    def update_map_from_port_mapping(self, port_mapping: Mapping[str, str]) -> None:
+        new_port_to_passed_variable_map = self.port_to_passed_variable_map.copy()
+        for old_key, new_key in port_mapping.items():
+            if old_key in new_port_to_passed_variable_map:
+                new_port_to_passed_variable_map[new_key] = (
+                    new_port_to_passed_variable_map.pop(old_key)
+                )
+        self.port_to_passed_variable_map = new_port_to_passed_variable_map
+
+    def update_map_from_inout_port_mapping(
+        self, port_mapping: Mapping[str, Tuple[str, str]]
+    ) -> None:
+        new_port_to_passed_variable_map = self.port_to_passed_variable_map.copy()
+        for old_key, (new_key1, new_key2) in port_mapping.items():
+            if old_key in new_port_to_passed_variable_map:
+                value = new_port_to_passed_variable_map.pop(old_key)
+                new_port_to_passed_variable_map[new_key1] = value
+                new_port_to_passed_variable_map[new_key2] = value
+        self.port_to_passed_variable_map = new_port_to_passed_variable_map
+
 
 class DebugInfoCollection(BaseModel):
     # Pydantic only started supporting UUID as keys in Pydantic V2

classiq/interface/execution/primitives.py

@@ -0,0 +1,17 @@
+from typing import List, Optional
+
+from pydantic import BaseModel, Field
+
+from classiq.interface.chemistry.operator import PauliOperator
+from classiq.interface.executor.quantum_code import Arguments
+from classiq.interface.helpers.custom_encoders import CUSTOM_ENCODERS
+
+
+class EstimateInput(BaseModel, json_encoders=CUSTOM_ENCODERS):
+    hamiltonian: PauliOperator
+    parameters: List[Arguments]
+
+
+class PrimitivesInput(BaseModel, json_encoders=CUSTOM_ENCODERS):
+    sample: Optional[List[Arguments]] = Field(default=None)
+    estimate: Optional[EstimateInput] = Field(default=None)

classiq/interface/executor/iqae_result.py

@@ -1,6 +1,6 @@
-from typing import List, Tuple
+from typing import List
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 from classiq.interface.executor.result import ExecutionDetails
 from classiq.interface.generator.functions.classical_type import QmodPyObject
@@ -14,6 +14,6 @@ class IQAEIterationData(BaseModel):
 
 class IQAEResult(VersionedModel, QmodPyObject):
     estimation: float
-    confidence_interval: Tuple[float, float]
+    confidence_interval: List[float] = Field(min_items=2, max_items=2)
     iterations_data: List[IQAEIterationData]
     warnings: List[str]

classiq/interface/executor/result.py

@@ -305,7 +305,9 @@ class EstimationMetadata(BaseModel, extra=pydantic.Extra.allow):
 
 class EstimationResult(BaseModel, QmodPyObject):
     value: Complex = pydantic.Field(..., description="Estimation for the operator")
-    variance: Complex = pydantic.Field(..., description="Variance of the estimation")
+    variance: Optional[Complex] = pydantic.Field(
+        description="Variance of the estimation", default=None
+    )
     metadata: EstimationMetadata = pydantic.Field(
         ..., description="Metadata for the estimation"
     )

classiq/interface/generator/arith/arithmetic_operations.py

@@ -1,5 +1,5 @@
 import abc
-from typing import ClassVar, Iterable, Optional, Tuple
+from typing import ClassVar, Final, Iterable, Optional, Tuple
 
 import pydantic
 
@@ -9,7 +9,10 @@ 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
 
-DEFAULT_GARBAGE_OUT_NAME: str = "extra_qubits"
+DEFAULT_GARBAGE_OUT_NAME: Final[str] = "extra_qubits"
+MODULO_WITH_FRACTION_PLACES_ERROR_MSG: Final[str] = (
+    "Modulo with fraction places not supported"
+)
 
 
 class ArithmeticOperationParams(FunctionParams):