classiq 0.51.1__py3-none-any.whl → 0.53.0__py3-none-any.whl

classiq/interface/generator/grover_operator.py

@@ -1,6 +1,7 @@
 from typing import Any, Dict, Optional
 
 import pydantic
+from pydantic_core.core_schema import ValidationInfo
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.function_params import (
@@ -26,44 +27,53 @@ _DEFAULT_ORACLE_DISCRIMINATOR: FunctionParamsDiscriminator = (
 
 class GroverOperator(FunctionParams):
     oracle: str = pydantic.Field(
-        default=_DEFAULT_ORACLE_DISCRIMINATOR, description="Oracle function"
+        default=_DEFAULT_ORACLE_DISCRIMINATOR,
+        description="Oracle function",
+        validate_default=True,
     )
     oracle_params: OracleABC = pydantic.Field(description="Oracle function parameters")
     state_preparation: str = pydantic.Field(
-        default="", description="State preparation function"
+        default="",
+        description="State preparation function",
+        validate_default=True,
     )
     state_preparation_params: GroverStatePreparation = pydantic.Field(
-        default=None, description="State preparation function parameters"
+        default=None,
+        description="State preparation function parameters",
+        validate_default=True,
     )
 
     def _create_ios(self) -> None:
         self._inputs = {**self.oracle_params.inputs}
         self._outputs = {**self.oracle_params.outputs}
 
-    @pydantic.root_validator(pre=True)
-    def _parse_oracle(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        oracle_params = values.get("oracle_params")
-        if isinstance(oracle_params, dict):
-            values["oracle_params"] = parse_function_params(
-                params=oracle_params,
-                discriminator=values.get("oracle", _DEFAULT_ORACLE_DISCRIMINATOR),
-                param_classes=oracle_function_param_library.param_list,
-                no_discriminator_error=ClassiqValueError("Invalid oracle name"),
-                bad_function_error=ClassiqValueError("Invalid oracle params"),
-            )
-        elif isinstance(oracle_params, FunctionParams):
-            values["oracle"] = oracle_params.discriminator()
-        else:
-            raise ClassiqValueError("Invalid oracle params")
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _parse_oracle(cls, values: Any) -> Dict[str, Any]:
+        if isinstance(values, dict):
+            oracle_params = values.get("oracle_params")
+            if isinstance(oracle_params, dict):
+                values["oracle_params"] = parse_function_params(
+                    params=oracle_params,
+                    discriminator=values.get("oracle", _DEFAULT_ORACLE_DISCRIMINATOR),
+                    param_classes=oracle_function_param_library.param_list,
+                    no_discriminator_error=ClassiqValueError("Invalid oracle name"),
+                    bad_function_error=ClassiqValueError("Invalid oracle params"),
+                )
+            elif isinstance(oracle_params, FunctionParams):
+                values["oracle"] = oracle_params.discriminator()
+            else:
+                raise ClassiqValueError("Invalid oracle params")
         return values
 
-    @pydantic.validator("state_preparation_params", always=True)
+    @pydantic.field_validator("state_preparation_params", mode="before")
+    @classmethod
     def _validate_state_preparation(
         cls,
         state_preparation_params: Optional[GroverStatePreparation],
-        values: Dict[str, Any],
+        info: ValidationInfo,
     ) -> GroverStatePreparation:
-        oracle = values.get("oracle_params")
+        oracle = info.data.get("oracle_params")
         assert oracle is not None, "Must receive an oracle"
         state_preparation_params = (
             state_preparation_params
@@ -73,7 +83,7 @@ class GroverOperator(FunctionParams):
         )
         assert GroverDiffuser(
             state_preparation_params=state_preparation_params,
-            state_preparation=values.get("state_preparation", ""),
+            state_preparation=info.data.get("state_preparation", ""),
             variables=oracle.variables(),
         ), "Cannot construct a GroverDiffuser"
         return state_preparation_params

classiq/interface/generator/hamiltonian_evolution/exponentiation.py

@@ -23,9 +23,7 @@ class ExponentiationConstraints(pydantic.BaseModel):
         default=None,
         description="Maximum approximation error of the exponentiation circuit.",
     )
-
-    class Config:
-        frozen = True
+    model_config = pydantic.ConfigDict(frozen=True)
 
 
 class Exponentiation(HamiltonianEvolution):
@@ -45,6 +43,7 @@ class Exponentiation(HamiltonianEvolution):
         description="What attribute to optimize.",
     )
 
-    @pydantic.validator("pauli_operator")
+    @pydantic.field_validator("pauli_operator")
+    @classmethod
     def _validate_is_hermitian(cls, pauli_operator: PauliOperator) -> PauliOperator:
         return operator.validate_operator_is_hermitian(pauli_operator)

classiq/interface/generator/hamiltonian_evolution/qdrift.py

@@ -2,10 +2,10 @@ import pydantic
 
 from classiq.interface.chemistry import operator
 from classiq.interface.chemistry.operator import PauliOperator
+from classiq.interface.generator.function_params import FunctionParamsNumericParameter
 from classiq.interface.generator.hamiltonian_evolution.hamiltonian_evolution import (
     HamiltonianEvolution,
 )
-from classiq.interface.generator.parameters import ParameterFloatType
 
 
 class QDrift(HamiltonianEvolution):
@@ -13,15 +13,15 @@ class QDrift(HamiltonianEvolution):
     qDrift trotterization of a Hermitian operator; see https://arxiv.org/abs/1811.08017
     """
 
-    evolution_coefficient: ParameterFloatType = pydantic.Field(
+    evolution_coefficient: FunctionParamsNumericParameter = pydantic.Field(
         default=1.0,
         description="A global coefficient multiplying the operator.",
-        is_exec_param=True,
     )
     num_qdrift: pydantic.PositiveInt = pydantic.Field(
         description="The number of elements in the qDrift product.",
     )
 
-    @pydantic.validator("pauli_operator")
+    @pydantic.field_validator("pauli_operator")
+    @classmethod
     def _validate_is_hermitian(cls, pauli_operator: PauliOperator) -> PauliOperator:
         return operator.validate_operator_is_hermitian(pauli_operator)

classiq/interface/generator/hamiltonian_evolution/suzuki_trotter.py

@@ -1,12 +1,13 @@
 import pydantic
+from pydantic import ConfigDict
 
 from classiq.interface.chemistry import operator
 from classiq.interface.chemistry.operator import PauliOperator
 from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.function_params import FunctionParamsNumericParameter
 from classiq.interface.generator.hamiltonian_evolution.hamiltonian_evolution import (
     HamiltonianEvolution,
 )
-from classiq.interface.generator.parameters import ParameterFloatType
 
 
 class SuzukiParameters(pydantic.BaseModel):
@@ -18,7 +19,8 @@ class SuzukiParameters(pydantic.BaseModel):
         default=1, description="The number of repetitions in the Suzuki-Trotter"
     )
 
-    @pydantic.validator("order")
+    @pydantic.field_validator("order")
+    @classmethod
     def _validate_order(cls, order: int) -> int:
         if order != 1 and order % 2:
             raise ClassiqValueError(
@@ -26,8 +28,7 @@ class SuzukiParameters(pydantic.BaseModel):
             )
         return order
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
 
 class SuzukiTrotter(HamiltonianEvolution):
@@ -35,10 +36,9 @@ class SuzukiTrotter(HamiltonianEvolution):
     Suzuki trotterization of a Hermitian operator
     """
 
-    evolution_coefficient: ParameterFloatType = pydantic.Field(
+    evolution_coefficient: FunctionParamsNumericParameter = pydantic.Field(
         default=1.0,
         description="A global coefficient multiplying the operator.",
-        is_exec_param=True,
     )
     suzuki_parameters: SuzukiParameters = pydantic.Field(
         default_factory=SuzukiParameters, description="The Suziki parameters."
@@ -47,7 +47,8 @@ class SuzukiTrotter(HamiltonianEvolution):
         default=False, description="Whether to disable the reordering of Pauli terms."
     )
 
-    @pydantic.validator("pauli_operator")
+    @pydantic.field_validator("pauli_operator")
+    @classmethod
     def _validate_no_complex_coefficients(
         cls, pauli_operator: PauliOperator
     ) -> PauliOperator:

classiq/interface/generator/hardware/hardware_data.py

@@ -3,6 +3,7 @@ from collections import defaultdict
 from typing import Any, Dict, List, MutableSet, Optional
 
 import pydantic
+from typing_extensions import Self
 
 from classiq.interface.backend.backend_preferences import BackendPreferences
 from classiq.interface.exceptions import ClassiqValueError
@@ -60,7 +61,8 @@ class HardwareData(pydantic.BaseModel):
         "If false, the first / second qubit denotes the control / target, respectively",
     )
 
-    @pydantic.validator("connectivity_map")
+    @pydantic.field_validator("connectivity_map")
+    @classmethod
     def _validate_connectivity_map(
         cls, connectivity_map: Optional[ConnectivityMap]
     ) -> Optional[ConnectivityMap]:
@@ -71,39 +73,37 @@ class HardwareData(pydantic.BaseModel):
         connectivity_map = _reindex_qubits(connectivity_map)
         return connectivity_map
 
-    @pydantic.root_validator()
-    def _symmetrize_connectivity_map(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        connectivity_map = values.get("connectivity_map")
+    @pydantic.model_validator(mode="after")
+    def _symmetrize_connectivity_map(self) -> Self:
+        connectivity_map = self.connectivity_map
         if connectivity_map is None:
-            return values
+            return self
 
-        is_symmetric = values.get("is_symmetric_connectivity")
+        is_symmetric = self.is_symmetric_connectivity
         if is_symmetric:
             connectivity_map = _symmetrize_connectivity_map(connectivity_map)
-            values["connectivity_map"] = connectivity_map
+            self.connectivity_map = connectivity_map
 
         if not _is_connected_map(connectivity_map):
             raise ClassiqValueError(
                 f"Connectivity map must be connected: {connectivity_map} is not connected."
             )
-        return values
+        return self
 
-    @pydantic.root_validator()
-    def _validate_basis_gates(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        connectivity_map = values.get("connectivity_map")
-        specified_basis_gates = values.get("basis_gates", [])
+    @pydantic.model_validator(mode="after")
+    def _validate_basis_gates(self) -> Self:
+        connectivity_map = self.connectivity_map
+        specified_basis_gates = self.basis_gates
         if connectivity_map is None:
-            values["basis_gates"] = specified_basis_gates or list(DEFAULT_BASIS_GATES)
-            return values
+            self.basis_gates = specified_basis_gates or list(DEFAULT_BASIS_GATES)
+            return self
 
-        is_symmetric_connectivity = values.get("is_symmetric")
+        is_symmetric_connectivity = self.is_symmetric_connectivity
         if is_symmetric_connectivity or _check_symmetry(connectivity_map):
-            values["basis_gates"] = specified_basis_gates or list(DEFAULT_BASIS_GATES)
-            return values
+            self.basis_gates = specified_basis_gates or list(DEFAULT_BASIS_GATES)
+            return self
 
-        values["basis_gates"] = specified_basis_gates or list(
-            DEFAULT_ROUTING_BASIS_GATES
-        )
+        self.basis_gates = specified_basis_gates or list(DEFAULT_ROUTING_BASIS_GATES)
         invalid_gates = [
             gate
             for gate in specified_basis_gates
@@ -115,7 +115,7 @@ class HardwareData(pydantic.BaseModel):
                 "is currently supported for the following two-qubit gates only: cx, ecr, rzx."
             )
 
-        return values
+        return self
 
 
 class CustomHardwareSettings(HardwareData):
@@ -127,7 +127,8 @@ class CustomHardwareSettings(HardwareData):
 
     _width: Optional[int] = pydantic.PrivateAttr(default=None)
 
-    @pydantic.validator("basis_gates")
+    @pydantic.field_validator("basis_gates", mode="after")
+    @classmethod
     def validate_basis_gates(cls, basis_gates: List[str]) -> List[TranspilerBasisGates]:
         valid_gates = list(TranspilerBasisGates)
         invalid_gates = [gate for gate in basis_gates if gate not in valid_gates]
@@ -179,7 +180,7 @@ def _node_dfs(
 
 def _reindex_qubits(connectivity_map: ConnectivityMap) -> ConnectivityMap:
     qubits = sorted({q for pair in connectivity_map for q in pair})
-    return [(qubits.index(pair[0]), qubits.index(pair[1])) for pair in connectivity_map]
+    return [[qubits.index(pair[0]), qubits.index(pair[1])] for pair in connectivity_map]
 
 
 def _check_symmetry(connectivity_map: ConnectivityMap) -> bool:
@@ -191,14 +192,14 @@ def _symmetrize_connectivity_map(connectivity_map: ConnectivityMap) -> Connectiv
     # A more complicated implementation than using set to maintain the order
     connectivity_map_no_duplicates = []
     for edge in connectivity_map:
-        reversed_edge = (edge[1], edge[0])
+        reversed_edge = [edge[1], edge[0]]
         if (
             edge not in connectivity_map_no_duplicates
             and reversed_edge not in connectivity_map_no_duplicates
         ):
             connectivity_map_no_duplicates.append(edge)
     reversed_connectivity_map = [
-        (edge[1], edge[0]) for edge in connectivity_map_no_duplicates
+        [edge[1], edge[0]] for edge in connectivity_map_no_duplicates
     ]
     return connectivity_map_no_duplicates + reversed_connectivity_map
 
@@ -217,4 +218,4 @@ class SynthesisHardwareData(HardwareData):
             Defaults to `None`.
     """
 
-    backend_data: Optional[BackendPreferences]
+    backend_data: Optional[BackendPreferences] = pydantic.Field(default=None)

classiq/interface/generator/hardware_efficient_ansatz.py

@@ -1,7 +1,8 @@
 import itertools
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, List, Optional, Union
 
 import pydantic
+from pydantic_core.core_schema import ValidationInfo
 
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.exceptions import ClassiqValueError
@@ -44,6 +45,7 @@ class HardwareEfficientAnsatz(function_params.FunctionParams):
     num_qubits: pydantic.PositiveInt = pydantic.Field(
         default=None,
         description="Number of qubits in the ansatz.",
+        validate_default=True,
     )
     reps: pydantic.PositiveInt = pydantic.Field(
         default=1, description="Number of layers in the Ansatz"
@@ -62,11 +64,12 @@ class HardwareEfficientAnsatz(function_params.FunctionParams):
         description="Prefix for the generated parameters",
     )
 
-    @pydantic.validator("num_qubits", pre=True, always=True)
+    @pydantic.field_validator("num_qubits", mode="before")
+    @classmethod
     def validate_num_qubits(
-        cls, num_qubits: Optional[pydantic.PositiveInt], values: Dict[str, Any]
+        cls, num_qubits: Optional[pydantic.PositiveInt], info: ValidationInfo
     ) -> pydantic.PositiveInt:
-        connectivity_map = values.get("connectivity_map")
+        connectivity_map = info.data.get("connectivity_map")
         conn_map_is_not_list = (
             isinstance(connectivity_map, SupportedConnectivityMaps)
             or connectivity_map is None
@@ -101,7 +104,8 @@ class HardwareEfficientAnsatz(function_params.FunctionParams):
             )
         return num_qubits
 
-    @pydantic.validator("one_qubit_gates")
+    @pydantic.field_validator("one_qubit_gates")
+    @classmethod
     def validate_one_qubit_gates(
         cls, one_qubit_gates: Union[str, List[str]]
     ) -> Union[str, List[str]]:
@@ -113,7 +117,8 @@ class HardwareEfficientAnsatz(function_params.FunctionParams):
                 raise ClassiqValueError(f"Invalid one qubit gate: {one_qubit_gate}")
         return one_qubit_gates
 
-    @pydantic.validator("two_qubit_gates")
+    @pydantic.field_validator("two_qubit_gates")
+    @classmethod
     def validate_two_qubit_gates(
         cls, two_qubit_gates: Union[str, List[str]]
     ) -> Union[str, List[str]]:

classiq/interface/generator/hartree_fock.py

@@ -14,7 +14,8 @@ from classiq.interface.generator.chemistry_function_params import (
 
 
 class HartreeFock(ChemistryFunctionParams):
-    @pydantic.validator("gs_problem")
+    @pydantic.field_validator("gs_problem")
+    @classmethod
     def validate_gs_problem(
         cls, gs_problem: Any
     ) -> Union[MoleculeProblem, HamiltonianProblem]:

classiq/interface/generator/identity.py

@@ -1,6 +1,8 @@
 from typing import TYPE_CHECKING, List
 
 import pydantic
+from pydantic import Field
+from typing_extensions import Annotated
 
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.function_params import FunctionParams
@@ -8,7 +10,9 @@ from classiq.interface.generator.function_params import FunctionParams
 if TYPE_CHECKING:
     NonEmptyRegisterUserInputList = List[RegisterUserInput]
 else:
-    NonEmptyRegisterUserInputList = pydantic.conlist(RegisterUserInput, min_items=1)
+    NonEmptyRegisterUserInputList = Annotated[
+        List[RegisterUserInput], Field(min_length=1)
+    ]
 
 
 class Identity(FunctionParams):
@@ -16,7 +20,8 @@ class Identity(FunctionParams):
         description="registers describing the state (ordered)"
     )
 
-    @pydantic.validator("arguments")
+    @pydantic.field_validator("arguments")
+    @classmethod
     def _validate_argument_names(
         cls, arguments: List[RegisterUserInput]
     ) -> List[RegisterUserInput]:

classiq/interface/generator/linear_pauli_rotations.py

@@ -1,6 +1,8 @@
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import TYPE_CHECKING, Any, List
 
 import pydantic
+from pydantic import StringConstraints
+from typing_extensions import Annotated, Self
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator import function_params
@@ -9,15 +11,18 @@ from classiq.interface.generator.arith.register_user_input import RegisterArithm
 STATE = "state"
 TARGET = "target"
 
-LENGTH_ERROR_MESSAGE = "Slopes, offsets and basis values must have the same length"
+LENGTH_ERROR_MESSAGE = "Field required"
 
 if TYPE_CHECKING:
     PydanticPauliBasisStr = str
 else:
-    PydanticPauliBasisStr = pydantic.constr(
-        to_lower=True,
-        regex=r"[xyz]",
-    )
+    PydanticPauliBasisStr = Annotated[
+        str,
+        StringConstraints(
+            to_lower=True,
+            pattern=r"[xyz]",
+        ),
+    ]
 
 
 class LinearPauliRotations(function_params.FunctionParams):
@@ -56,19 +61,27 @@ class LinearPauliRotations(function_params.FunctionParams):
         description="The offsets of the controlled rotations."
     )
 
-    @pydantic.validator("bases", "slopes", "offsets", pre=True, always=True)
+    @pydantic.field_validator("bases", "slopes", "offsets", mode="before")
+    @classmethod
     def as_list(cls, v: Any) -> List[Any]:
         if not isinstance(v, list):
             v = [v]
-        return v
+        res = []
+        for x in v:
+            element = x
+            if isinstance(x, str):
+                res.append(element.lower())
+            else:
+                res.append(element)
+        return res
 
-    @pydantic.root_validator()
-    def validate_lists(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        offsets = values.get("offsets", list())
-        bases = values.get("bases", list())
-        slopes = values.get("slopes", list())
+    @pydantic.model_validator(mode="after")
+    def validate_lists(self) -> Self:
+        offsets = self.offsets or list()
+        bases = self.bases or list()
+        slopes = self.slopes or list()
         if len(slopes) == len(offsets) and len(offsets) == len(bases):
-            return values
+            return self
         raise ClassiqValueError(LENGTH_ERROR_MESSAGE)
 
     def _create_ios(self) -> None:

classiq/interface/generator/mcu.py

@@ -5,8 +5,10 @@ import pydantic
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.control_state import ControlState
-from classiq.interface.generator.function_params import FunctionParams
-from classiq.interface.generator.parameters import ParameterFloatType
+from classiq.interface.generator.function_params import (
+    FunctionParams,
+    FunctionParamsNumericParameter,
+)
 
 CTRL = "CTRL"
 TARGET = "TARGET"
@@ -29,17 +31,17 @@ class Mcu(FunctionParams):
     e^(i*phi)*sin(theta/2)  &    e^(i*(phi+lam))*cos(theta/2) \\
     """
 
-    theta: ParameterFloatType = pydantic.Field(
-        default=0, description="Theta radian angle.", is_exec_param=True
+    theta: FunctionParamsNumericParameter = pydantic.Field(
+        default=0, description="Theta radian angle."
     )
-    phi: ParameterFloatType = pydantic.Field(
-        default=0, description="Phi radian angle.", is_exec_param=True
+    phi: FunctionParamsNumericParameter = pydantic.Field(
+        default=0, description="Phi radian angle."
     )
-    lam: ParameterFloatType = pydantic.Field(
-        default=0, description="Lambda radian angle.", is_exec_param=True
+    lam: FunctionParamsNumericParameter = pydantic.Field(
+        default=0, description="Lambda radian angle."
     )
-    gam: ParameterFloatType = pydantic.Field(
-        default=0, description="gam radian angle.", is_exec_param=True
+    gam: FunctionParamsNumericParameter = pydantic.Field(
+        default=0, description="gam radian angle."
     )
 
     num_ctrl_qubits: Optional[pydantic.PositiveInt] = pydantic.Field(
@@ -49,8 +51,9 @@ class Mcu(FunctionParams):
         default=None, description="string of the control state"
     )
 
-    @pydantic.root_validator()
-    def _validate_control(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _validate_control(cls, values: Any) -> Dict[str, Any]:
         num_ctrl_qubits = values.get("num_ctrl_qubits")
         ctrl_state = values.get("ctrl_state")
 

classiq/interface/generator/mcx.py

@@ -1,6 +1,7 @@
 from typing import Any, Dict, List, Optional
 
 import pydantic
+from pydantic_core.core_schema import ValidationInfo
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
@@ -20,11 +21,15 @@ class Mcx(FunctionParams):
         default_factory=list, description="registers describing the state (ordered)"
     )
     num_ctrl_qubits: Optional[pydantic.PositiveInt] = pydantic.Field(
-        description="number of control qubits"
+        description="number of control qubits",
+        default=None,
+    )
+    ctrl_state: str = pydantic.Field(
+        default="", description="control state string", validate_default=True
     )
-    ctrl_state: str = pydantic.Field(default="", description="control state string")
 
-    @pydantic.validator("arguments", always=True)
+    @pydantic.field_validator("arguments")
+    @classmethod
     def _validate_argument_names(
         cls, arguments: List[RegisterUserInput]
     ) -> List[RegisterUserInput]:
@@ -35,10 +40,11 @@ class Mcx(FunctionParams):
             raise ClassiqValueError("Registers must have distinct names")
         return arguments
 
-    @pydantic.validator("num_ctrl_qubits", always=True)
-    def _validate_sizes(cls, num_ctrl_qubits: int, values: Dict[str, Any]) -> int:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _validate_sizes(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         arguments_size = sum(arg.size for arg in values.get("arguments", list()))
-
+        num_ctrl_qubits = values.get("num_ctrl_qubits")
         if not num_ctrl_qubits:
             num_ctrl_qubits = arguments_size - 1
 
@@ -51,11 +57,13 @@ class Mcx(FunctionParams):
             values["arguments"] = [ctrl_register, target_register]
         elif num_ctrl_qubits != arguments_size - 1:
             raise ClassiqValueError("Given sizes do not match")
-        return num_ctrl_qubits
+        values["num_ctrl_qubits"] = num_ctrl_qubits
+        return values
 
-    @pydantic.validator("ctrl_state", always=True)
-    def _validate_ctrl_state(cls, ctrl_state: str, values: Dict[str, Any]) -> str:
-        num_ctrl_qubits = values.get("num_ctrl_qubits", -1)
+    @pydantic.field_validator("ctrl_state")
+    @classmethod
+    def _validate_ctrl_state(cls, ctrl_state: str, info: ValidationInfo) -> str:
+        num_ctrl_qubits = info.data.get("num_ctrl_qubits", -1)
         if not ctrl_state:
             return "1" * num_ctrl_qubits
         if len(ctrl_state) != num_ctrl_qubits:

classiq/interface/generator/model/constraints.py

@@ -2,7 +2,7 @@ from collections import defaultdict
 from typing import Dict, Optional, Union
 
 import pydantic
-from pydantic import BaseModel, Extra
+from pydantic import BaseModel, ConfigDict
 
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.exceptions import ClassiqValueError
@@ -29,7 +29,7 @@ def optimization_parameter_type_from_string(param: str) -> OptimizationParameter
     raise ClassiqValueError(f"Invalid OptimizationParameterType {param}")
 
 
-class Constraints(BaseModel, extra=Extra.forbid):
+class Constraints(BaseModel):
     """
     Constraints for the quantum circuit synthesis engine.
 
@@ -51,6 +51,8 @@ class Constraints(BaseModel, extra=Extra.forbid):
             the solution. Defaults to `NO_OPTIMIZATION`. See `OptimizationParameterType`
     """
 
+    model_config = ConfigDict(extra="forbid")
+
     max_width: Optional[pydantic.PositiveInt] = pydantic.Field(
         default=None,
         description="Maximum number of qubits in generated quantum circuit",

classiq/interface/generator/model/model.py

@@ -51,7 +51,8 @@ class ClassiqBaseModel(VersionedModel, ABC):
         default_factory=ExecutionPreferences
     )
 
-    @pydantic.validator("types")
+    @pydantic.field_validator("types")
+    @classmethod
     def types_validator(cls, types: List[StructDeclaration]) -> List[StructDeclaration]:
         if not is_list_unique([struct_type.name for struct_type in types]):
             raise ClassiqValueError(TYPE_LIBRARY_DUPLICATED_TYPE_NAMES)