classiq 0.37.1__py3-none-any.whl → 0.39.0__py3-none-any.whl

classiq/interface/backend/quantum_backend_providers.py

@@ -56,6 +56,7 @@ class AzureQuantumBackendNames(StrEnum):
     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"
     QCI_MACHINE1 = "qci.machine1"
     QCI_NOISY_SIMULATOR = "qci.simulator.noisy"
     QCI_SIMULATOR = "qci.simulator"

classiq/interface/chemistry/fermionic_operator.py

@@ -10,6 +10,8 @@ from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
 
+from classiq.exceptions import ClassiqValueError
+
 LadderOperator = Tuple[str, int]
 FermionicOperatorTuple = Tuple["FermionicOperator", float]
 
@@ -46,19 +48,19 @@ class FermionicOperator(HashablePydanticBaseModel):
             try:  # type: ignore[unreachable] # it is reachable...
                 op = tuple(op)
             except Exception as exc:
-                raise ValueError("Ladder operator should be a tuple.") from exc
+                raise ClassiqValueError("Ladder operator should be a tuple.") from exc
         if len(op) != 2:
-            raise ValueError(
+            raise ClassiqValueError(
                 "Ladder operator tuple should be of length two; for example (1, '+')."
             )
 
         if op[0] not in ("+", "-"):
-            raise ValueError(
+            raise ClassiqValueError(
                 "The first term in a ladder operator tuple indicates if its a raising ('+')"
                 f" or lowering ('-') operator. Allowed input is: '+' or '-', received {op[0]}"
             )
         if not isinstance(op[1], int):
-            raise ValueError(
+            raise ClassiqValueError(
                 "The second term in a ladder operator tuple indicates its index and should be of type int"
             )
 
@@ -71,7 +73,7 @@ class FermionicOperator(HashablePydanticBaseModel):
     def __mul__(self, coeff: Union[float, int]) -> SummedFermionicOperator:
         if isinstance(coeff, (float, int)):
             return SummedFermionicOperator(op_list=[(self, float(coeff))])
-        raise ValueError(
+        raise ClassiqValueError(
             "The coefficient multiplying Fermionic Operator should be of type float"
         )
 
@@ -84,7 +86,7 @@ class FermionicOperator(HashablePydanticBaseModel):
             return SummedFermionicOperator(op_list=[(self, 1.0)] + other.op_list)
         elif isinstance(other, FermionicOperator):
             return SummedFermionicOperator(op_list=[(self, 1.0)] + [(other, 1.0)])
-        raise ValueError(
+        raise ClassiqValueError(
             "FermionicOperator can be summed together only with type FermionicOperator or SummedFermionicOperator"
         )
 
@@ -135,21 +137,21 @@ class SummedFermionicOperator(HashablePydanticBaseModel):
             try:  # type: ignore[unreachable] # it is reachable...
                 op = tuple(op)
             except Exception as exc:
-                raise ValueError("Operator should be a tuple.") from exc
+                raise ClassiqValueError("Operator should be a tuple.") from exc
         if len(op) != 2:
-            raise ValueError("Operator tuple should be of length two.")
+            raise ClassiqValueError("Operator tuple should be of length two.")
 
         # is it FermionicOperator - if not, convert to FermionicOperator
-        if type(op[0]) is not FermionicOperator:
+        if not isinstance(op[0], FermionicOperator):
             try:
                 op = (FermionicOperator(**op[0]), op[1])
             except Exception as exc:
-                raise ValueError(
+                raise ClassiqValueError(
                     "The first term in the operator tuple should be an instance of the FermionicOperator class"
                 ) from exc
 
-        if type(op[1]) is not float:
-            raise ValueError(
+        if not isinstance(op[1], float):
+            raise ClassiqValueError(
                 "The second term in the operator tuple indicates its coefficient and should be of type float"
             )
 
@@ -166,7 +168,7 @@ class SummedFermionicOperator(HashablePydanticBaseModel):
             return SummedFermionicOperator(op_list=self.op_list + other.op_list)
         elif isinstance(other, FermionicOperator):
             return SummedFermionicOperator(op_list=self.op_list + [(other, 1.0)])
-        raise ValueError(
+        raise ClassiqValueError(
             "FermionicOperator can be summed together only with type FermionicOperator or SummedFermionicOperator"
         )
 

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

@@ -3,6 +3,7 @@ from typing import Dict, Tuple
 
 import networkx as nx
 import pyomo.core as pyo
+import pyomo.core.expr.numeric_expr as pyo_expr
 
 Node = int
 Edge = Tuple[Node, Node]
@@ -22,7 +23,9 @@ 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_expr.ExpressionBase:
             out_nodes = [
                 node_id for node_id in model.Nodes if [idx, node_id] in model.Arcs
             ]
@@ -32,7 +35,9 @@ 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_expr.ExpressionBase:
             in_nodes = [
                 node_id for node_id in model.Nodes if [node_id, idx] in model.Arcs
             ]
@@ -41,7 +46,7 @@ def build_mht_pyomo_model(
             else:
                 return pyo.Constraint.Feasible
 
-    def obj_expression(model):
+    def obj_expression(model: pyo.ConcreteModel) -> pyo_expr.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