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

classiq/interface/chemistry/operator.py

@@ -1,18 +1,26 @@
+from collections.abc import Collection
 from functools import reduce
-from typing import Any, Collection, Dict, List, Optional, Tuple, Union, cast
+from typing import (
+    Any,
+    Optional,
+    Union,
+    cast,
+)
 
 import numpy as np
 import pydantic
 import sympy
 from more_itertools import all_equal
+from pydantic import ConfigDict
 
-from classiq.interface.generator.expressions.enums.pauli import Pauli
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.function_params import validate_expression_str
 from classiq.interface.generator.parameters import (
     ParameterComplexType,
     ParameterType,
     PydanticParameterComplexType,
 )
+from classiq.interface.generator.types.builtin_enum_declarations import Pauli
 from classiq.interface.helpers.custom_pydantic_types import (
     PydanticPauliList,
     PydanticPauliMonomial,
@@ -23,8 +31,6 @@ from classiq.interface.helpers.hashable_pydantic_base_model import (
 )
 from classiq.interface.helpers.versioned_model import VersionedModel
 
-from classiq.exceptions import ClassiqValueError
-
 
 class PauliOperator(HashablePydanticBaseModel, VersionedModel):
     """
@@ -34,8 +40,8 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
     pauli_list: PydanticPauliList = pydantic.Field(
         description="A list of tuples each containing a pauli string comprised of I,X,Y,Z characters and a complex coefficient; for example [('IZ', 0.1), ('XY', 0.2)].",
     )
-    is_hermitian: bool = pydantic.Field(default=False)
     has_complex_coefficients: bool = pydantic.Field(default=True)
+    is_hermitian: bool = pydantic.Field(default=False)
 
     def show(self) -> str:
         if self.is_hermitian:
@@ -47,16 +53,19 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
             f"+({summand[1]:+.3f}) * {summand[0]}" for summand in self.pauli_list
         )
 
-    @pydantic.validator("pauli_list", each_item=True, pre=True)
+    @pydantic.field_validator("pauli_list", mode="before")
+    @classmethod
     def _validate_pauli_monomials(
-        cls, monomial: Tuple[PydanticPauliMonomialStr, ParameterComplexType]
-    ) -> Tuple[PydanticPauliMonomialStr, ParameterComplexType]:
-        _PauliMonomialLengthValidator(  # type: ignore[call-arg]
-            monomial=monomial
-        )  # Validate the length of the monomial.
-        coeff = cls._validate_monomial_coefficient(monomial[1])
-        parsed_monomial = _PauliMonomialParser(string=monomial[0], coeff=coeff)  # type: ignore[call-arg]
-        return (parsed_monomial.string, parsed_monomial.coeff)
+        cls, pauli_list: PydanticPauliList
+    ) -> PydanticPauliList:
+        validated_pauli_list = []
+        for monomial in pauli_list:
+            # Validate the length
+            _PauliMonomialLengthValidator(monomial=monomial)  # type: ignore[call-arg]
+            coeff = cls._validate_monomial_coefficient(monomial[1])
+            parsed_monomial = _PauliMonomialParser(string=monomial[0], coeff=coeff)
+            validated_pauli_list.append((parsed_monomial.string, parsed_monomial.coeff))
+        return validated_pauli_list
 
     @staticmethod
     def _validate_monomial_coefficient(
@@ -68,16 +77,38 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
             coeff = str(coeff)
         return coeff
 
-    @pydantic.validator("pauli_list")
+    @pydantic.field_validator("pauli_list", mode="after")
+    @classmethod
     def _validate_pauli_list(cls, pauli_list: PydanticPauliList) -> PydanticPauliList:
         if not all_equal(len(summand[0]) for summand in pauli_list):
             raise ClassiqValueError("Pauli strings have incompatible lengths.")
         return pauli_list
 
-    @pydantic.root_validator
-    def _validate_hermitianity(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @staticmethod
+    def check_if_hermitian(pauli_list: PydanticPauliList) -> bool:
+        if all(isinstance(summand[1], (float, int, complex)) for summand in pauli_list):
+            if all(np.isclose(summand[1].imag, 0) for summand in pauli_list):  # type: ignore[union-attr]
+                return True
+
+            for pauli_string, coeff in pauli_list:
+                reverse_string = pauli_string[::-1]
+                reverse_found = False
+                for other_string, other_coeff in pauli_list:
+                    if other_string == reverse_string and np.isclose(
+                        coeff, other_coeff.conjugate()  # type: ignore[union-attr]
+                    ):
+                        reverse_found = True
+                        break
+                if not reverse_found:
+                    return False
+            return True
+        return False
+
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _validate_hermitianity(cls, values: dict[str, Any]) -> dict[str, Any]:
         pauli_list = values.get("pauli_list", [])
-        if all(isinstance(summand[1], complex) for summand in pauli_list):
+        if PauliOperator.check_if_hermitian(pauli_list):
             values["is_hermitian"] = all(
                 np.isclose(complex(summand[1]).real, summand[1])
                 for summand in pauli_list
@@ -85,7 +116,7 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
         if values.get("is_hermitian", False):
             values["has_complex_coefficients"] = False
             values["pauli_list"] = [
-                (summand[0], complex(summand[1].real)) for summand in pauli_list
+                (summand[0], complex(summand[1]).real) for summand in pauli_list
             ]
         else:
             values["has_complex_coefficients"] = not all(
@@ -120,7 +151,7 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
         )
 
     @staticmethod
-    def _is_sub_pauli_commutative(qubit_pauli_string: Union[List[str], str]) -> bool:
+    def _is_sub_pauli_commutative(qubit_pauli_string: Union[list[str], str]) -> bool:
         unique_paulis = set(qubit_pauli_string) - {"I"}
         return len(unique_paulis) <= 1
 
@@ -128,8 +159,12 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
     def num_qubits(self) -> int:
         return len(self.pauli_list[0][0])
 
+    @property
+    def all_coefficients_numeric(self) -> bool:
+        return all(isinstance(summand[1], complex) for summand in self.pauli_list)
+
     def to_matrix(self) -> np.ndarray:
-        if not all(isinstance(summand[1], complex) for summand in self.pauli_list):
+        if not self.all_coefficients_numeric:
             raise ClassiqValueError(
                 "Supporting only Hamiltonian with numeric coefficients."
             )
@@ -149,7 +184,7 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
             (self._extend_pauli_string(pauli_string, num_extra_qubits), coeff)
             for (pauli_string, coeff) in self.pauli_list
         ]
-        return self.copy(update={"pauli_list": new_pauli_list}, deep=True)
+        return self.model_copy(update={"pauli_list": new_pauli_list}, deep=True)
 
     @staticmethod
     def _reorder_pauli_string(
@@ -199,13 +234,13 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
             (cls._reorder_pauli_string(pauli_string, order, new_num_qubits), coeff)
             for pauli_string, coeff in operator.pauli_list
         ]
-        return cls(pauli_list=new_pauli_list)
+        return cls(pauli_list=new_pauli_list, is_hermitian=operator.is_hermitian)
 
     @classmethod
     def from_unzipped_lists(
         cls,
-        operators: List[List[Pauli]],
-        coefficients: Optional[List[complex]] = None,
+        operators: list[list["Pauli"]],
+        coefficients: Optional[list[complex]] = None,
     ) -> "PauliOperator":
         if coefficients is None:
             coefficients = [1] * len(operators)
@@ -222,208 +257,7 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
             ]
         )
 
-    class Config:
-        frozen = True
-
-
-class PauliOperatorV1(HashablePydanticBaseModel):
-    """
-    Specification of a Pauli sum operator.
-    """
-
-    pauli_list: PydanticPauliList = pydantic.Field(
-        description="A list of tuples each containing a pauli string comprised of I,X,Y,Z characters and a complex coefficient; for example [('IZ', 0.1), ('XY', 0.2)].",
-    )
-    is_hermitian: bool = pydantic.Field(default=False)
-    has_complex_coefficients: bool = pydantic.Field(default=True)
-
-    def show(self) -> str:
-        if self.is_hermitian:
-            # If the operator is hermitian then the coefficients must be numeric
-            return "\n".join(
-                f"{summand[1].real:+.3f} * {summand[0]}" for summand in self.pauli_list  # type: ignore[union-attr]
-            )
-        return "\n".join(
-            f"+({summand[1]:+.3f}) * {summand[0]}" for summand in self.pauli_list
-        )
-
-    @pydantic.validator("pauli_list", each_item=True, pre=True)
-    def _validate_pauli_monomials(
-        cls, monomial: Tuple[PydanticPauliMonomialStr, ParameterComplexType]
-    ) -> Tuple[PydanticPauliMonomialStr, ParameterComplexType]:
-        _PauliMonomialLengthValidator(  # type: ignore[call-arg]
-            monomial=monomial
-        )  # Validate the length of the monomial.
-        coeff = cls._validate_monomial_coefficient(monomial[1])
-        parsed_monomial = _PauliMonomialParser(string=monomial[0], coeff=coeff)  # type: ignore[call-arg]
-        return (parsed_monomial.string, parsed_monomial.coeff)
-
-    @staticmethod
-    def _validate_monomial_coefficient(
-        coeff: Union[sympy.Expr, ParameterComplexType]
-    ) -> ParameterComplexType:
-        if isinstance(coeff, str):
-            validate_expression_str(coeff)
-        elif isinstance(coeff, sympy.Expr):
-            coeff = str(coeff)
-        return coeff
-
-    @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 ClassiqValueError("Pauli strings have incompatible lengths.")
-        return pauli_list
-
-    @pydantic.root_validator
-    def _validate_hermitianity(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        pauli_list = values.get("pauli_list", [])
-        if all(isinstance(summand[1], complex) for summand in pauli_list):
-            values["is_hermitian"] = all(
-                np.isclose(complex(summand[1]).real, summand[1])
-                for summand in pauli_list
-            )
-        if values.get("is_hermitian", False):
-            values["has_complex_coefficients"] = False
-            values["pauli_list"] = [
-                (summand[0], complex(summand[1].real)) for summand in pauli_list
-            ]
-        else:
-            values["has_complex_coefficients"] = not all(
-                np.isclose(complex(summand[1]).real, summand[1])
-                for summand in pauli_list
-                if isinstance(summand[1], complex)
-            )
-        return values
-
-    def __mul__(self, coefficient: complex) -> "PauliOperatorV1":
-        multiplied_ising = [
-            (monomial[0], self._multiply_monomial_coefficient(monomial[1], coefficient))
-            for monomial in self.pauli_list
-        ]
-        return self.__class__(pauli_list=multiplied_ising)
-
-    @staticmethod
-    def _multiply_monomial_coefficient(
-        monomial_coefficient: ParameterComplexType, coefficient: complex
-    ) -> ParameterComplexType:
-        if isinstance(monomial_coefficient, ParameterType):
-            return str(sympy.sympify(monomial_coefficient) * coefficient)
-        return monomial_coefficient * coefficient
-
-    @property
-    def is_commutative(self) -> bool:
-        return all(
-            self._is_sub_pauli_commutative(
-                [summand[0][qubit_num] for summand in self.pauli_list]
-            )
-            for qubit_num in range(self.num_qubits)
-        )
-
-    @staticmethod
-    def _is_sub_pauli_commutative(qubit_pauli_string: Union[List[str], str]) -> bool:
-        unique_paulis = set(qubit_pauli_string) - {"I"}
-        return len(unique_paulis) <= 1
-
-    @property
-    def num_qubits(self) -> int:
-        return len(self.pauli_list[0][0])
-
-    def to_matrix(self) -> np.ndarray:
-        if not all(isinstance(summand[1], complex) for summand in self.pauli_list):
-            raise ClassiqValueError(
-                "Supporting only Hamiltonian with numeric coefficients."
-            )
-        return sum(
-            cast(complex, summand[1]) * to_pauli_matrix(summand[0])
-            for summand in self.pauli_list
-        )  # type: ignore[return-value]
-
-    @staticmethod
-    def _extend_pauli_string(
-        pauli_string: PydanticPauliMonomialStr, num_extra_qubits: int
-    ) -> PydanticPauliMonomialStr:
-        return "I" * num_extra_qubits + pauli_string
-
-    def extend(self, num_extra_qubits: int) -> "PauliOperatorV1":
-        new_pauli_list = [
-            (self._extend_pauli_string(pauli_string, num_extra_qubits), coeff)
-            for (pauli_string, coeff) in self.pauli_list
-        ]
-        return self.copy(update={"pauli_list": new_pauli_list}, deep=True)
-
-    @staticmethod
-    def _reorder_pauli_string(
-        pauli_string: PydanticPauliMonomialStr,
-        order: Collection[int],
-        new_num_qubits: int,
-    ) -> PydanticPauliMonomialStr:
-        reversed_pauli_string = pauli_string[::-1]
-        reversed_new_pauli_string = ["I"] * new_num_qubits
-
-        for logical_pos, actual_pos in enumerate(order):
-            reversed_new_pauli_string[actual_pos] = reversed_pauli_string[logical_pos]
-
-        return "".join(reversed(reversed_new_pauli_string))
-
-    @staticmethod
-    def _validate_reorder(
-        order: Collection[int],
-        num_qubits: int,
-        num_extra_qubits: int,
-    ) -> None:
-        if num_extra_qubits < 0:
-            raise ClassiqValueError("Number of extra qubits cannot be negative")
-
-        if len(order) != num_qubits:
-            raise ClassiqValueError("The qubits order doesn't match the Pauli operator")
-
-        if len(order) != len(set(order)):
-            raise ClassiqValueError("The qubits order is not one-to-one")
-
-        if not all(pos < num_qubits + num_extra_qubits for pos in order):
-            raise ClassiqValueError(
-                "The qubits order contains qubits which do no exist"
-            )
-
-    @classmethod
-    def reorder(
-        cls,
-        operator: "PauliOperatorV1",
-        order: Collection[int],
-        num_extra_qubits: int = 0,
-    ) -> "PauliOperatorV1":
-        cls._validate_reorder(order, operator.num_qubits, num_extra_qubits)
-
-        new_num_qubits = operator.num_qubits + num_extra_qubits
-        new_pauli_list = [
-            (cls._reorder_pauli_string(pauli_string, order, new_num_qubits), coeff)
-            for pauli_string, coeff in operator.pauli_list
-        ]
-        return cls(pauli_list=new_pauli_list)
-
-    @classmethod
-    def from_unzipped_lists(
-        cls,
-        operators: List[List[Pauli]],
-        coefficients: Optional[List[complex]] = None,
-    ) -> "PauliOperatorV1":
-        if coefficients is None:
-            coefficients = [1] * len(operators)
-
-        if len(operators) != len(coefficients):
-            raise ClassiqValueError(
-                f"The number of coefficients ({len(coefficients)}) must be equal to the number of pauli operators ({len(operators)})"
-            )
-
-        return cls(
-            pauli_list=[
-                (pauli_integers_to_str(op), coeff)
-                for op, coeff in zip(operators, coefficients)
-            ]
-        )
-
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
 
 # This class validates the length of a monomial.
@@ -432,8 +266,7 @@ class _PauliMonomialLengthValidator:
     monomial: PydanticPauliMonomial
 
 
-@pydantic.dataclasses.dataclass
-class _PauliMonomialParser:
+class _PauliMonomialParser(pydantic.BaseModel):
     string: PydanticPauliMonomialStr
     coeff: PydanticParameterComplexType
 
@@ -466,9 +299,9 @@ def validate_operator_has_no_complex_coefficients(
     return pauli_operator
 
 
-def pauli_integers_to_str(paulis: List[Pauli]) -> str:
+def pauli_integers_to_str(paulis: list[Pauli]) -> str:
     return "".join([Pauli(pauli).name for pauli in paulis])
 
 
 class PauliOperators(VersionedModel):
-    operators: List[PauliOperator]
+    operators: list[PauliOperator]

classiq/interface/combinatorial_optimization/encoding_types.py

@@ -1,4 +1,4 @@
-from classiq._internals.enum_utils import StrEnum
+from classiq.interface.enum_utils import StrEnum
 
 
 class EncodingType(StrEnum):

classiq/interface/combinatorial_optimization/examples/ascending_sequence.py

@@ -1,10 +1,8 @@
-from typing import List
-
 import numpy as np
 import pyomo.core as pyo
 
 
-def ascending_sequence(coeffs: List[int], bound: int) -> pyo.ConcreteModel:
+def ascending_sequence(coeffs: list[int], bound: int) -> pyo.ConcreteModel:
     model = pyo.ConcreteModel()
     model.x = pyo.Var(
         range(len(coeffs)), domain=pyo.NonNegativeIntegers, bounds=(0, bound)

classiq/interface/combinatorial_optimization/examples/integer_portfolio_optimization.py

@@ -1,16 +1,14 @@
-from typing import List, Tuple
-
 import numpy as np
 import pyomo.core as pyo
 
 
 def integer_portfolio_optimization(
-    covariances: np.ndarray, returns: np.ndarray, upper_bounds: List[int]
+    covariances: np.ndarray, returns: np.ndarray, upper_bounds: list[int]
 ) -> pyo.ConcreteModel:
     model = pyo.ConcreteModel()
     num_assets = len(returns)
 
-    def bounds(model: pyo.ConcreteModel, i: int) -> Tuple[int, int]:
+    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/knapsack.py

@@ -1,13 +1,13 @@
-from typing import List, Optional
+from typing import Optional
 
 import numpy as np
 import pyomo.core as pyo
 
 
 def knapsack(
-    values: List[int],
+    values: list[int],
     upper_bound: int,
-    weights: Optional[List[int]] = None,
+    weights: Optional[list[int]] = None,
     max_weight: Optional[int] = None,
 ) -> pyo.ConcreteModel:
     model = pyo.ConcreteModel()

classiq/interface/combinatorial_optimization/examples/mht.py

@@ -1,12 +1,12 @@
 import math
-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]
-Pubo = Dict[Tuple[Edge, ...], float]
+Edge = tuple[Node, Node]
+Pubo = dict[tuple[Edge, ...], float]
 
 
 def build_mht_pyomo_model(
@@ -22,7 +22,9 @@ def build_mht_pyomo_model(
     if has_constraints:
 
         @model.Constraint(model.Nodes)
-        def out_edges_rule(model: pyo.ConcreteModel, idx: int) -> pyo.ExpressionBase:
+        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 +34,9 @@ def build_mht_pyomo_model(
                 return pyo.Constraint.Feasible
 
         @model.Constraint(model.Nodes)
-        def in_edges_rule(model: pyo.ConcreteModel, idx: int) -> pyo.ExpressionBase:
+        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 +45,7 @@ def build_mht_pyomo_model(
             else:
                 return pyo.Constraint.Feasible
 
-    def obj_expression(model: pyo.ConcreteModel) -> pyo.ExpressionBase:
+    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/portfolio_variations.py

@@ -1,9 +1,9 @@
-from typing import List, Tuple, Union
+from typing import Union
 
 import numpy as np
 import pyomo.core as pyo
 
-BoundsList = List[Union[Tuple[int, int], int]]
+BoundsList = list[Union[tuple[int, int], int]]
 
 
 def portfolio_optimization_binary(

classiq/interface/combinatorial_optimization/examples/set_cover.py

@@ -1,11 +1,10 @@
 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:
+def set_cover(sub_sets: list[list[int]]) -> pyo.ConcreteModel:
     entire_set = set(itertools.chain(*sub_sets))
     n = max(entire_set)
     num_sets = len(sub_sets)

classiq/interface/combinatorial_optimization/mht_qaoa_input.py

@@ -1,11 +1,9 @@
-from typing import List
-
 import more_itertools
 import numpy as np
 import pydantic
 from pydantic import BaseModel
 
-from classiq.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqValueError
 
 _TOLERANCE_DECIMALS = 6
 
@@ -24,7 +22,7 @@ class MhtQaoaInput(BaseModel):
     reps: pydantic.PositiveInt = pydantic.Field(
         default=3, description="Number of QAOA layers."
     )
-    plot_list: List[PlotData] = pydantic.Field(
+    plot_list: list[PlotData] = pydantic.Field(
         description="The list of (x,y,t) plots of the MHT problem."
     )
     misdetection_maximum_time_steps: pydantic.NonNegativeInt = pydantic.Field(
@@ -53,10 +51,11 @@ class MhtQaoaInput(BaseModel):
     def is_valid_cost(self, cost: float) -> bool:
         return True
 
-    @pydantic.validator("plot_list")
+    @pydantic.field_validator("plot_list")
+    @classmethod
     def round_plot_list_times_and_validate(
-        cls, plot_list: List[PlotData]
-    ) -> List[PlotData]:
+        cls, plot_list: list[PlotData]
+    ) -> list[PlotData]:
         MhtQaoaInput._check_all_ids_are_distinct(plot_list)
         MhtQaoaInput._round_to_tolerance_decimals(plot_list)
 
@@ -74,11 +73,11 @@ class MhtQaoaInput(BaseModel):
         return plot_list
 
     @staticmethod
-    def _round_to_tolerance_decimals(plot_list: List[PlotData]) -> None:
+    def _round_to_tolerance_decimals(plot_list: list[PlotData]) -> None:
         for plot in plot_list:
             plot.t = np.round(plot.t, decimals=_TOLERANCE_DECIMALS)
 
     @staticmethod
-    def _check_all_ids_are_distinct(plot_list: List[PlotData]) -> None:
+    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 ClassiqValueError("Plot IDs should be unique.")

classiq/interface/combinatorial_optimization/optimization_problem.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict
+from typing import Any
 
 import pydantic
 from pydantic import BaseModel
@@ -14,4 +14,4 @@ class MaxCutProblem(BaseModel):
         default_factory=CombinatorialOptimizer,
         description="preferences for the VQE execution",
     )
-    serialized_graph: Dict[str, Any]
+    serialized_graph: dict[str, Any]

classiq/interface/combinatorial_optimization/result.py

@@ -1,10 +1,8 @@
-from typing import List
-
 from classiq.interface.helpers.versioned_model import VersionedModel
 
 
 class AnglesResult(VersionedModel):
-    initial_point: List[float]
+    initial_point: list[float]
 
 
 class PyomoObjectResult(VersionedModel):

classiq/interface/combinatorial_optimization/solver_types.py

@@ -1,4 +1,4 @@
-from classiq._internals.enum_utils import StrEnum
+from classiq.interface.enum_utils import StrEnum
 
 
 class QSolver(StrEnum):