classiq 0.37.0__py3-none-any.whl → 0.38.0__py3-none-any.whl

classiq/interface/chemistry/ground_state_problem.py

@@ -1,6 +1,8 @@
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Literal, Optional, Tuple, Union
 
 import pydantic
+from pydantic import Field
+from typing_extensions import Annotated
 
 from classiq.interface.chemistry.fermionic_operator import SummedFermionicOperator
 from classiq.interface.chemistry.molecule import Molecule
@@ -9,6 +11,7 @@ from classiq.interface.helpers.hashable_pydantic_base_model import (
 )
 
 from classiq._internals.enum_utils import StrEnum
+from classiq.exceptions import ClassiqValueError
 
 """
 The correct type hint is:
@@ -37,6 +40,8 @@ class FermionMapping(StrEnum):
 
 
 class GroundStateProblem(HashablePydanticBaseModel):
+    kind: str
+
     mapping: FermionMapping = pydantic.Field(
         default=FermionMapping.JORDAN_WIGNER,
         description="Fermionic mapping type",
@@ -53,7 +58,7 @@ class GroundStateProblem(HashablePydanticBaseModel):
         cls, z2_symmetries: bool, values: Dict[str, Any]
     ) -> bool:
         if z2_symmetries and values.get("mapping") == FermionMapping.FAST_BRAVYI_KITAEV:
-            raise ValueError(
+            raise ClassiqValueError(
                 "z2 symmetries reduction can not be used for fast_bravyi_kitaev mapping"
             )
         return z2_symmetries
@@ -63,6 +68,8 @@ class GroundStateProblem(HashablePydanticBaseModel):
 
 
 class MoleculeProblem(GroundStateProblem):
+    kind: Literal["molecule"] = pydantic.Field(default="molecule")
+
     molecule: Molecule
     basis: str = pydantic.Field(default="sto3g", description="Molecular basis set")
     freeze_core: bool = pydantic.Field(default=False)
@@ -72,6 +79,8 @@ class MoleculeProblem(GroundStateProblem):
 
 
 class HamiltonianProblem(GroundStateProblem):
+    kind: Literal["hamiltonian"] = pydantic.Field(default="hamiltonian")
+
     hamiltonian: SummedFermionicOperator = pydantic.Field(
         description="Hamiltonian as a fermionic operator"
     )
@@ -96,5 +105,11 @@ class HamiltonianProblem(GroundStateProblem):
 
 
 CHEMISTRY_PROBLEMS = (MoleculeProblem, HamiltonianProblem)
-CHEMISTRY_PROBLEMS_TYPE = Union[MoleculeProblem, HamiltonianProblem]
+CHEMISTRY_PROBLEMS_TYPE = Annotated[
+    Union[MoleculeProblem, HamiltonianProblem],
+    Field(
+        discriminator="kind",
+        description="Ground state problem object describing the system.",
+    ),
+]
 CHEMISTRY_ANSATZ_NAMES = ["hw_efficient", "ucc", "hva"]

classiq/interface/chemistry/molecule.py

@@ -8,6 +8,8 @@ from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
 
+from classiq.exceptions import ClassiqValueError
+
 
 class Atom(HashablePydanticBaseModel):
     symbol: Literal[tuple(ELEMENTS)] = pydantic.Field(description="The atom symbol")  # type: ignore[valid-type]
@@ -41,20 +43,20 @@ class Molecule(HashablePydanticBaseModel):
     @staticmethod
     def _validate_old_atoms_type(atom: AtomType) -> Atom:
         if len(atom) != 2:
-            raise ValueError(
+            raise ClassiqValueError(
                 "each atom should be a list of two entries: 1) name pf the elemnt (str) 2) list of its (x,y,z) location"
             )
-        if type(atom[0]) is not str:
-            raise ValueError(
+        if not isinstance(atom[0], str):
+            raise ClassiqValueError(
                 f"atom name should be a string. unknown element: {atom[0]}."
             )
         if len(atom[1]) != 3:
-            raise ValueError(
+            raise ClassiqValueError(
                 f"location of the atom is of length three, representing the (x,y,z) coordinates of the atom, error value: {atom[1]}"
             )
         for idx in atom[1]:
-            if type(idx) is not float and type(idx) is not int:
-                raise ValueError(
+            if not isinstance(idx, (float, int)):
+                raise ClassiqValueError(
                     f"coordinates of the atom should be of type float. error value: {idx}"
                 )
         symbol, coordinate = atom

classiq/interface/chemistry/operator.py

@@ -71,7 +71,7 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
     @pydantic.validator("pauli_list")
     def _validate_pauli_list(cls, pauli_list: PydanticPauliList) -> PydanticPauliList:
         if not all_equal(len(summand[0]) for summand in pauli_list):
-            raise ValueError("Pauli strings have incompatible lengths.")
+            raise ClassiqValueError("Pauli strings have incompatible lengths.")
         return pauli_list
 
     @pydantic.root_validator
@@ -172,16 +172,18 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
         num_extra_qubits: int,
     ) -> None:
         if num_extra_qubits < 0:
-            raise ValueError("Number of extra qubits cannot be negative")
+            raise ClassiqValueError("Number of extra qubits cannot be negative")
 
         if len(order) != num_qubits:
-            raise ValueError("The qubits order doesn't match the Pauli operator")
+            raise ClassiqValueError("The qubits order doesn't match the Pauli operator")
 
         if len(order) != len(set(order)):
-            raise ValueError("The qubits order is not one-to-one")
+            raise ClassiqValueError("The qubits order is not one-to-one")
 
         if not all(pos < num_qubits + num_extra_qubits for pos in order):
-            raise ValueError("The qubits order contains qubits which do no exist")
+            raise ClassiqValueError(
+                "The qubits order contains qubits which do no exist"
+            )
 
     @classmethod
     def reorder(
@@ -209,7 +211,7 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
             coefficients = [1] * len(operators)
 
         if len(operators) != len(coefficients):
-            raise ValueError(
+            raise ClassiqValueError(
                 f"The number of coefficients ({len(coefficients)}) must be equal to the number of pauli operators ({len(operators)})"
             )
 
@@ -269,7 +271,7 @@ class PauliOperatorV1(HashablePydanticBaseModel):
     @pydantic.validator("pauli_list")
     def _validate_pauli_list(cls, pauli_list: PydanticPauliList) -> PydanticPauliList:
         if not all_equal(len(summand[0]) for summand in pauli_list):
-            raise ValueError("Pauli strings have incompatible lengths.")
+            raise ClassiqValueError("Pauli strings have incompatible lengths.")
         return pauli_list
 
     @pydantic.root_validator
@@ -370,16 +372,18 @@ class PauliOperatorV1(HashablePydanticBaseModel):
         num_extra_qubits: int,
     ) -> None:
         if num_extra_qubits < 0:
-            raise ValueError("Number of extra qubits cannot be negative")
+            raise ClassiqValueError("Number of extra qubits cannot be negative")
 
         if len(order) != num_qubits:
-            raise ValueError("The qubits order doesn't match the Pauli operator")
+            raise ClassiqValueError("The qubits order doesn't match the Pauli operator")
 
         if len(order) != len(set(order)):
-            raise ValueError("The qubits order is not one-to-one")
+            raise ClassiqValueError("The qubits order is not one-to-one")
 
         if not all(pos < num_qubits + num_extra_qubits for pos in order):
-            raise ValueError("The qubits order contains qubits which do no exist")
+            raise ClassiqValueError(
+                "The qubits order contains qubits which do no exist"
+            )
 
     @classmethod
     def reorder(
@@ -407,7 +411,7 @@ class PauliOperatorV1(HashablePydanticBaseModel):
             coefficients = [1] * len(operators)
 
         if len(operators) != len(coefficients):
-            raise ValueError(
+            raise ClassiqValueError(
                 f"The number of coefficients ({len(coefficients)}) must be equal to the number of pauli operators ({len(operators)})"
             )
 
@@ -448,7 +452,7 @@ def to_pauli_matrix(pauli_op: PydanticPauliMonomialStr) -> np.ndarray:
 
 def validate_operator_is_hermitian(pauli_operator: PauliOperator) -> PauliOperator:
     if not pauli_operator.is_hermitian:
-        raise ValueError("Coefficients of the Hamiltonian must be real numbers")
+        raise ClassiqValueError("Coefficients of the Hamiltonian must be real numbers")
     return pauli_operator
 
 
@@ -456,7 +460,9 @@ def validate_operator_has_no_complex_coefficients(
     pauli_operator: PauliOperator,
 ) -> PauliOperator:
     if pauli_operator.has_complex_coefficients:
-        raise ValueError("Coefficients of the Hamiltonian mustn't be complex numbers")
+        raise ClassiqValueError(
+            "Coefficients of the Hamiltonian mustn't be complex numbers"
+        )
     return pauli_operator
 
 

classiq/interface/combinatorial_optimization/examples/ascending_sequence.py

@@ -11,7 +11,7 @@ def ascending_sequence(coeffs: List[int], bound: int) -> pyo.ConcreteModel:
     )
 
     @model.Constraint(range(len(coeffs) - 1))
-    def monotone_rule(model, idx):
+    def monotone_rule(model: pyo.ConcreteModel, idx: int) -> pyo.ExpressionBase:
         return model.x[idx] <= model.x[idx + 1]
 
     model.cost = pyo.Objective(

classiq/interface/combinatorial_optimization/examples/greater_than_ilp.py

@@ -19,7 +19,7 @@ def greater_than_ilp(
     )
 
     @model.Constraint(range(num_constraints))
-    def monotone_rule(model, idx):
+    def monotone_rule(model: pyo.ConcreteModel, idx: int) -> pyo.ExpressionBase:
         return a[idx, :] @ list(model.x.values()) >= float(b[idx])
 
     # model objective: max(c * x)

classiq/interface/combinatorial_optimization/examples/ilp.py

@@ -1,5 +1,6 @@
 import numpy as np
 import pyomo.core as pyo
+import pyomo.core.expr.numeric_expr as pyo_expr
 
 
 def ilp(a: np.ndarray, b: np.ndarray, c: np.ndarray, bound: int) -> pyo.ConcreteModel:
@@ -17,7 +18,7 @@ def ilp(a: np.ndarray, b: np.ndarray, c: np.ndarray, bound: int) -> pyo.Concrete
     )
 
     @model.Constraint(range(num_constraints))
-    def monotone_rule(model, idx):
+    def monotone_rule(model: pyo.ConcreteModel, idx: int) -> pyo_expr.ExpressionBase:
         return a[idx, :] @ list(model.x.values()) <= float(b[idx])
 
     # model objective: max(c * x)

classiq/interface/combinatorial_optimization/examples/integer_portfolio_optimization.py

@@ -1,4 +1,4 @@
-from typing import List
+from typing import List, Tuple
 
 import numpy as np
 import pyomo.core as pyo
@@ -10,7 +10,7 @@ def integer_portfolio_optimization(
     model = pyo.ConcreteModel()
     num_assets = len(returns)
 
-    def bounds(_, i):
+    def bounds(model: pyo.ConcreteModel, i: int) -> Tuple[int, int]:
         return 0, upper_bounds[i]
 
     model.x = pyo.Var(range(num_assets), domain=pyo.NonNegativeIntegers, bounds=bounds)

classiq/interface/combinatorial_optimization/examples/mds.py

@@ -1,5 +1,6 @@
 import networkx as nx
 import pyomo.core as pyo
+import pyomo.core.expr.numeric_expr as pyo_expr
 
 
 def mds(graph: nx.Graph) -> pyo.ConcreteModel:
@@ -7,7 +8,7 @@ def mds(graph: nx.Graph) -> pyo.ConcreteModel:
     model.x = pyo.Var(graph.nodes, domain=pyo.Binary)
 
     @model.Constraint(graph.nodes)
-    def dominating_rule(model, idx):
+    def dominating_rule(model: pyo.ConcreteModel, idx: int) -> pyo_expr.ExpressionBase:
         sum_of_neighbors = sum(model.x[neighbor] for neighbor in graph.neighbors(idx))
         return model.x[idx] + sum_of_neighbors >= 1
 

classiq/interface/combinatorial_optimization/examples/mht.py

@@ -22,7 +22,7 @@ def build_mht_pyomo_model(
     if has_constraints:
 
         @model.Constraint(model.Nodes)
-        def out_edges_rule(model, idx):
+        def out_edges_rule(model: pyo.ConcreteModel, idx: int) -> pyo.ExpressionBase:
             out_nodes = [
                 node_id for node_id in model.Nodes if [idx, node_id] in model.Arcs
             ]
@@ -32,7 +32,7 @@ def build_mht_pyomo_model(
                 return pyo.Constraint.Feasible
 
         @model.Constraint(model.Nodes)
-        def in_edges_rule(model, idx):
+        def in_edges_rule(model: pyo.ConcreteModel, idx: int) -> pyo.ExpressionBase:
             in_nodes = [
                 node_id for node_id in model.Nodes if [node_id, idx] in model.Arcs
             ]
@@ -41,7 +41,7 @@ def build_mht_pyomo_model(
             else:
                 return pyo.Constraint.Feasible
 
-    def obj_expression(model):
+    def obj_expression(model: pyo.ConcreteModel) -> pyo.ExpressionBase:
         return sum(
             round(pubo_energy, _decimals)
             * math.prod(model.x[edge] for edge in pubo_edges)

classiq/interface/combinatorial_optimization/examples/mis.py

@@ -1,5 +1,6 @@
 import networkx as nx
 import pyomo.core as pyo
+import pyomo.core.expr.numeric_expr as pyo_expr
 
 
 def mis(graph: nx.Graph) -> pyo.ConcreteModel:
@@ -7,7 +8,9 @@ def mis(graph: nx.Graph) -> pyo.ConcreteModel:
     model.x = pyo.Var(graph.nodes, domain=pyo.Binary)
 
     @model.Constraint(graph.edges)
-    def independent_rule(model, node1, node2):
+    def independent_rule(
+        model: pyo.ConcreteModel, node1: int, node2: int
+    ) -> pyo_expr.ExpressionBase:
         return model.x[node1] + model.x[node2] <= 1
 
     model.cost = pyo.Objective(expr=sum(model.x.values()), sense=pyo.maximize)

classiq/interface/combinatorial_optimization/examples/mvc.py

@@ -1,5 +1,6 @@
 import networkx as nx
 import pyomo.core as pyo
+import pyomo.core.expr.numeric_expr as pyo_expr
 
 
 def mvc(graph: nx.Graph, k: int) -> pyo.ConcreteModel:
@@ -7,7 +8,7 @@ def mvc(graph: nx.Graph, k: int) -> pyo.ConcreteModel:
     model.x = pyo.Var(graph.nodes, domain=pyo.Binary)
     model.amount_constraint = pyo.Constraint(expr=sum(model.x.values()) == k)
 
-    def obj_expression(model):
+    def obj_expression(model: pyo.ConcreteModel) -> pyo_expr.ExpressionBase:
         # number of edges not covered
         return sum((1 - model.x[i]) * (1 - model.x[j]) for i, j in graph.edges)
 

classiq/interface/combinatorial_optimization/examples/set_cover.py

@@ -2,6 +2,7 @@ import itertools
 from typing import List
 
 import pyomo.core as pyo
+import pyomo.core.expr.numeric_expr as pyo_expr
 
 
 def set_cover(sub_sets: List[List[int]]) -> pyo.ConcreteModel:
@@ -16,7 +17,7 @@ def set_cover(sub_sets: List[List[int]]) -> pyo.ConcreteModel:
     model.x = pyo.Var(range(num_sets), domain=pyo.Binary)
 
     @model.Constraint(entire_set)
-    def independent_rule(model, num):
+    def independent_rule(model: pyo.ConcreteModel, num: int) -> pyo_expr.ExpressionBase:
         return sum(model.x[idx] for idx in range(num_sets) if num in sub_sets[idx]) >= 1
 
     model.cost = pyo.Objective(expr=sum(model.x.values()), sense=pyo.minimize)

classiq/interface/combinatorial_optimization/examples/tsp.py

@@ -2,6 +2,7 @@ import itertools
 
 import numpy as np
 import pyomo.core as pyo
+import pyomo.core.expr.numeric_expr as pyo_expr
 
 
 def tsp(distance_matrix: np.ndarray) -> pyo.ConcreteModel:
@@ -22,16 +23,16 @@ def tsp(distance_matrix: np.ndarray) -> pyo.ConcreteModel:
     @model.Constraint(points)
     def each_step_visits_one_point_rule(
         model: pyo.ConcreteModel, ii: int
-    ) -> pyo.ExpressionBase:
+    ) -> pyo_expr.ExpressionBase:
         return sum(model.x[ii, jj] for jj in range(num_points)) == 1
 
     @model.Constraint(points)
     def each_point_visited_once_rule(
         model: pyo.ConcreteModel, jj: int
-    ) -> pyo.ExpressionBase:
+    ) -> pyo_expr.ExpressionBase:
         return sum(model.x[ii, jj] for ii in range(num_points)) == 1
 
-    def is_travel_between_2_points(point1: int, point2: int) -> pyo.ExpressionBase:
+    def is_travel_between_2_points(point1: int, point2: int) -> pyo_expr.ExpressionBase:
         return sum(model.x[point1, kk] * model.x[point2, kk + 1] for kk in points[:-1])
 
     model.cost = pyo.Objective(

classiq/interface/combinatorial_optimization/examples/tsp_digraph.py

@@ -21,11 +21,15 @@ def tsp_digraph(
     )  # x[i, j] = 1 indicates that point i is visited at step j
 
     @model.Constraint(points)
-    def each_step_visits_one_point_rule(model, ii):
+    def each_step_visits_one_point_rule(
+        model: pyo.ConcreteModel, ii: int
+    ) -> pyo.ExpressionBase:
         return sum(model.x[ii, jj] for jj in steps) == 1
 
     @model.Constraint(steps)
-    def each_point_visited_once_rule(model, jj):
+    def each_point_visited_once_rule(
+        model: pyo.ConcreteModel, jj: int
+    ) -> pyo.ExpressionBase:
         return sum(model.x[ii, jj] for ii in points) == 1
 
     def is_travel_between_2_points(point1: int, point2: int) -> pyo.ExpressionBase:

classiq/interface/combinatorial_optimization/mht_qaoa_input.py

@@ -5,6 +5,8 @@ import numpy as np
 import pydantic
 from pydantic import BaseModel
 
+from classiq.exceptions import ClassiqValueError
+
 _TOLERANCE_DECIMALS = 6
 
 
@@ -52,7 +54,9 @@ class MhtQaoaInput(BaseModel):
         return True
 
     @pydantic.validator("plot_list")
-    def round_plot_list_times_and_validate(cls, plot_list):
+    def round_plot_list_times_and_validate(
+        cls, plot_list: List[PlotData]
+    ) -> List[PlotData]:
         MhtQaoaInput._check_all_ids_are_distinct(plot_list)
         MhtQaoaInput._round_to_tolerance_decimals(plot_list)
 
@@ -63,7 +67,9 @@ class MhtQaoaInput(BaseModel):
         }
 
         if len(time_diff_set) != 1:
-            raise ValueError("The time difference between each time stamp is not equal")
+            raise ClassiqValueError(
+                "The time difference between each time stamp is not equal"
+            )
 
         return plot_list
 
@@ -75,4 +81,4 @@ class MhtQaoaInput(BaseModel):
     @staticmethod
     def _check_all_ids_are_distinct(plot_list: List[PlotData]) -> None:
         if not more_itertools.all_unique(plot.plot_id for plot in plot_list):
-            raise ValueError("Plot IDs should be unique.")
+            raise ClassiqValueError("Plot IDs should be unique.")

classiq/interface/executor/aws_execution_cost.py

@@ -1,10 +1,11 @@
 from datetime import date
-from typing import List, Optional
+from typing import Any, Dict, List, Optional
 
 import pydantic
 from pydantic import validator
 
 from classiq._internals.enum_utils import StrEnum
+from classiq.exceptions import ClassiqValueError
 
 
 class Granularity(StrEnum):
@@ -37,9 +38,9 @@ class ExecutionCostForTimePeriod(pydantic.BaseModel):
         json_encoders = {date: lambda v: v.strftime("%Y-%m-%d")}
 
     @validator("end")
-    def date_order(cls, v, values, **kwargs):
+    def date_order(cls, v: date, values: Dict[str, Any], **kwargs: Any) -> date:
         if "start" in values and v <= values["start"]:
-            raise ValueError('"end" date should be after "start" date')
+            raise ClassiqValueError('"end" date should be after "start" date')
         return v
 
 

classiq/interface/executor/estimation.py

@@ -1,7 +1,7 @@
 import pydantic
 
 from classiq.interface.chemistry.operator import PauliOperators
-from classiq.interface.executor.quantum_program import QuantumProgram
+from classiq.interface.executor.quantum_code import QuantumCode
 
 
 class OperatorsEstimation(pydantic.BaseModel):
@@ -10,5 +10,5 @@ class OperatorsEstimation(pydantic.BaseModel):
     by a quantum program.
     """
 
-    quantum_program: QuantumProgram
+    quantum_program: QuantumCode
     operators: PauliOperators

classiq/interface/executor/execution_preferences.py

@@ -1,5 +1,5 @@
 from datetime import timedelta
-from typing import Any, Dict, List, Optional, TypeVar, Union
+from typing import Any, Dict, Optional, TypeVar
 
 import pydantic
 
@@ -23,6 +23,7 @@ from classiq.interface.generator.model.preferences.randomness import create_rand
 from classiq.interface.generator.noise_properties import NoiseProperties
 
 from classiq._internals.enum_utils import ReprEnum
+from classiq.exceptions import ClassiqValueError
 
 DIFFERENT_TIMEOUT_MSG = (
     "Timeout is defined differently in the execution preferences and the "
@@ -40,41 +41,12 @@ class QaeWithQpeEstimationMethod(int, ReprEnum):
     BEST_FIT = 1
 
 
-class AmplitudeAmplification(pydantic.BaseModel):
-    iterations: List[int] = pydantic.Field(
-        default_factory=list,
-        description="Number or list of numbers of iteration to use",
-    )
-    growth_rate: float = pydantic.Field(
-        default=1.25,
-        description="Number of iteration used is set to round(growth_rate**iterations)",
-    )
-    sample_from_iterations: bool = pydantic.Field(
-        default=False,
-        description="If True, number of iterations used is picked randomly from "
-        "[1, iteration] range",
-    )
-    num_of_highest_probability_states_to_check: pydantic.PositiveInt = pydantic.Field(
-        default=1, description="Then number of highest probability states to check"
-    )
-
-    @pydantic.validator("iterations")
-    def _validate_iterations(cls, iterations: Union[List[int], int]) -> List[int]:
-        if isinstance(iterations, int):
-            return [iterations]
-        return iterations
-
-
 class ExecutionPreferences(pydantic.BaseModel):
     timeout_sec: Optional[pydantic.PositiveInt] = pydantic.Field(
         default=None,
         description="If set, limits the execution runtime. Value is in seconds. "
         "Not supported on all platforms.",
     )
-    amplitude_amplification: AmplitudeAmplification = pydantic.Field(
-        default_factory=AmplitudeAmplification,
-        description="Settings related to amplitude amplification execution, used during the grover execution.",
-    )
     optimizer_preferences: Optional[OptimizerPreferences] = pydantic.Field(
         default_factory=None,
         description="Settings related to VQE execution.",
@@ -130,9 +102,9 @@ class ExecutionPreferences(pydantic.BaseModel):
             timeout != backend_preferences.job_timeout
             and backend_preferences.job_timeout != AWS_DEFAULT_JOB_TIMEOUT_SECONDS
         ):
-            raise ValueError(DIFFERENT_TIMEOUT_MSG)
+            raise ClassiqValueError(DIFFERENT_TIMEOUT_MSG)
         if timeout > MAX_EXECUTION_TIMEOUT_SECONDS:
-            raise ValueError(TIMEOUT_LARGE_FOR_AWS_MSG)
+            raise ClassiqValueError(TIMEOUT_LARGE_FOR_AWS_MSG)
 
         backend_preferences.job_timeout = timeout
         return backend_preferences
@@ -169,7 +141,7 @@ def _choose_original_or_optimizer_attribute(
         return optimizer_attribute
 
     elif original_attribute != optimizer_attribute:
-        raise ValueError(
+        raise ClassiqValueError(
             f"Different {attribure_name} were given for ExecutionPreferences and OptimizerPreferences."
         )
 
@@ -179,7 +151,6 @@ def _choose_original_or_optimizer_attribute(
 
 __all__ = [
     "ExecutionPreferences",
-    "AmplitudeAmplification",
     "ErrorMitigationMethod",
     "NoiseProperties",
     "OptimizerPreferences",

classiq/interface/executor/execution_request.py

@@ -2,38 +2,40 @@ from datetime import datetime
 from typing import Any, Dict, List, Literal, Optional, Union
 
 import pydantic
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
+from typing_extensions import Annotated
 
 from classiq.interface.backend.backend_preferences import IonqBackendPreferences
 from classiq.interface.executor.estimation import OperatorsEstimation
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
-from classiq.interface.executor.quantum_program import (
-    QuantumInstructionSet,
-    QuantumProgram,
-)
-from classiq.interface.generator.generated_circuit import GeneratedCircuit
+from classiq.interface.executor.quantum_code import QuantumCode, QuantumInstructionSet
+from classiq.interface.generator.quantum_program import QuantumProgram
+from classiq.interface.helpers.custom_encoders import CUSTOM_ENCODERS
 from classiq.interface.helpers.versioned_model import VersionedModel
 from classiq.interface.jobs import JobStatus
 
-
-class GeneratedCircuitExecution(GeneratedCircuit):
-    execution_type: Literal["generated_circuit"] = "generated_circuit"
+from classiq.exceptions import ClassiqValueError
 
 
 class QuantumProgramExecution(QuantumProgram):
-    execution_type: Literal["quantum_program"] = "quantum_program"
+    execution_type: Literal["quantum_program2"] = "quantum_program2"
+
+
+class QuantumCodeExecution(QuantumCode):
+    execution_type: Literal["quantum_code"] = "quantum_code"
 
 
 class EstimateOperatorsExecution(OperatorsEstimation):
     execution_type: Literal["estimate_operators"] = "estimate_operators"
 
 
-ExecutionPayloads = Union[
-    GeneratedCircuitExecution, QuantumProgramExecution, EstimateOperatorsExecution
+ExecutionPayloads = Annotated[
+    Union[QuantumProgramExecution, QuantumCodeExecution, EstimateOperatorsExecution],
+    Field(discriminator="execution_type"),
 ]
 
 
-class ExecutionRequest(BaseModel):
+class ExecutionRequest(BaseModel, json_encoders=CUSTOM_ENCODERS):
     execution_payload: ExecutionPayloads
     preferences: ExecutionPreferences = pydantic.Field(
         default_factory=ExecutionPreferences,
@@ -58,23 +60,23 @@ class ExecutionRequest(BaseModel):
         is_ionq_backend = isinstance(
             preferences.backend_preferences, IonqBackendPreferences
         )
-        if isinstance(quantum_program, QuantumProgram):
+        if isinstance(quantum_program, QuantumCode):
             if (
                 quantum_program.syntax == QuantumInstructionSet.IONQ
                 and not is_ionq_backend
             ):
-                raise ValueError("Can only execute IonQ code on IonQ backend.")
+                raise ClassiqValueError("Can only execute IonQ code on IonQ backend.")
         else:
             # If we handle anything other than a program.
             if is_ionq_backend:
-                raise ValueError(
+                raise ClassiqValueError(
                     "IonQ backend supports only execution of QuantumPrograms"
                 )
         return preferences
 
 
 class QuantumProgramExecutionRequest(ExecutionRequest):
-    execution_payload: QuantumProgramExecution
+    execution_payload: QuantumCodeExecution
 
 
 class ExecutionJobDetails(VersionedModel):