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

classiq/interface/generator/model/preferences/preferences.py

@@ -1,11 +1,12 @@
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence, Union
 
 import pydantic
-from typing_extensions import TypeAlias
+from pydantic import Field
+from pydantic_core.core_schema import ValidationInfo
+from typing_extensions import Annotated, Self, TypeAlias
 
 from classiq.interface.backend.backend_preferences import (
     BackendPreferences,
-    validate_backend_service_provider,
 )
 from classiq.interface.backend.quantum_backend_providers import (
     AllBackendsNameByVendor,
@@ -27,14 +28,14 @@ from classiq.interface.helpers.custom_pydantic_types import PydanticMachinePreci
 if TYPE_CHECKING:
     VisualizationLevel: TypeAlias = Optional[int]
 else:
-    VisualizationLevel: TypeAlias = Optional[pydantic.conint(ge=-1)]
+    VisualizationLevel: TypeAlias = Optional[Annotated[int, Field(ge=-1)]]
 
 if TYPE_CHECKING:
     PydanticBackendName = str
 else:
-    PydanticBackendName = pydantic.constr(
-        strict=True, min_length=1, regex="^([.A-Za-z0-9_-]*)$"
-    )
+    PydanticBackendName = Annotated[
+        str, Field(strict=True, min_length=1, pattern="^([.A-Za-z0-9_-]*)$")
+    ]
 
 
 class QuantumFormat(StrEnum):
@@ -57,9 +58,9 @@ _SERVICE_PROVIDER_TO_FORMAT: Dict[Provider, QuantumFormat] = {
 if TYPE_CHECKING:
     PydanticConstrainedQuantumFormatList = List[QuantumFormat]
 else:
-    PydanticConstrainedQuantumFormatList = pydantic.conlist(
-        QuantumFormat, min_items=1, max_items=len(QuantumFormat)
-    )
+    PydanticConstrainedQuantumFormatList = Annotated[
+        List[QuantumFormat], Field(min_length=1, max_length=len(QuantumFormat))
+    ]
 
 
 class TranspilationOption(StrEnum):
@@ -75,7 +76,7 @@ class TranspilationOption(StrEnum):
         return self != TranspilationOption.NONE
 
 
-class Preferences(pydantic.BaseModel, extra=pydantic.Extra.forbid):
+class Preferences(pydantic.BaseModel, extra="forbid"):
     """
     Preferences for synthesizing a quantum circuit.
 
@@ -194,21 +195,14 @@ class Preferences(pydantic.BaseModel, extra=pydantic.Extra.forbid):
         description="The random seed used for the generation",
     )
 
-    @pydantic.validator("backend_service_provider", pre=True)
-    def validate_backend_service_provider(
-        cls, backend_service_provider: Any
-    ) -> Optional[Provider]:
-        if backend_service_provider is None:
-            return None
-        return validate_backend_service_provider(backend_service_provider)
-
-    @pydantic.validator("optimization_timeout_seconds")
+    @pydantic.field_validator("optimization_timeout_seconds", mode="before")
+    @classmethod
     def optimization_timeout_less_than_generation_timeout(
         cls,
         optimization_timeout_seconds: Optional[pydantic.PositiveInt],
-        values: Dict[str, Any],
+        info: ValidationInfo,
     ) -> Optional[pydantic.PositiveInt]:
-        generation_timeout_seconds = values.get("timeout_seconds")
+        generation_timeout_seconds = info.data.get("timeout_seconds")
         if generation_timeout_seconds is None or optimization_timeout_seconds is None:
             return optimization_timeout_seconds
         if optimization_timeout_seconds >= generation_timeout_seconds:
@@ -219,16 +213,20 @@ class Preferences(pydantic.BaseModel, extra=pydantic.Extra.forbid):
             )
         return optimization_timeout_seconds
 
-    @pydantic.validator("output_format", pre=True)
+    @pydantic.field_validator("output_format", mode="before")
+    @classmethod
     def make_output_format_list(cls, output_format: Any) -> List:
-        if not pydantic.utils.sequence_like(output_format):
+        if not isinstance(output_format, Sequence) or isinstance(output_format, str):
             output_format = [output_format]
 
         return output_format
 
-    @pydantic.validator("output_format", always=True)
+    @pydantic.field_validator("output_format", mode="before")
+    @classmethod
     def validate_output_format(
-        cls, output_format: PydanticConstrainedQuantumFormatList, values: Dict[str, Any]
+        cls,
+        output_format: PydanticConstrainedQuantumFormatList,
+        info: ValidationInfo,
     ) -> PydanticConstrainedQuantumFormatList:
         if len(output_format) != len(set(output_format)):
             raise ClassiqValueError(
@@ -236,7 +234,7 @@ class Preferences(pydantic.BaseModel, extra=pydantic.Extra.forbid):
                 "has at least one format that appears twice or more"
             )
 
-        service_provider = values.get("backend_service_provider")
+        service_provider = info.data.get("backend_service_provider")
         if service_provider is None:
             return output_format
 
@@ -246,13 +244,13 @@ class Preferences(pydantic.BaseModel, extra=pydantic.Extra.forbid):
 
         return output_format
 
-    @pydantic.root_validator()
-    def validate_backend(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        backend_name = values.get("backend_name")
-        backend_service_provider = values.get("backend_service_provider")
+    @pydantic.model_validator(mode="after")
+    def validate_backend(self) -> Self:
+        backend_name = self.backend_name
+        backend_service_provider = self.backend_service_provider
         if (backend_name is None) != (backend_service_provider is None):
             raise ClassiqValueError(BACKEND_VALIDATION_ERROR_MESSAGE)
-        return values
+        return self
 
     @property
     def backend_preferences(self) -> Optional[BackendPreferences]:

classiq/interface/generator/oracles/custom_oracle.py

@@ -22,18 +22,21 @@ class CustomOracle(OracleABC[QubitState]):
         default_factory=CustomFunction,
     )
 
-    @pydantic.root_validator(pre=True)
-    def _parse_oracle(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        parse_function_params_values(
-            values=values,
-            params_key="custom_oracle_params",
-            discriminator_key="custom_oracle",
-            param_classes={CustomFunction},
-            default_parser_class=CustomFunction,
-        )
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _parse_oracle(cls, values: Any) -> Dict[str, Any]:
+        if isinstance(values, dict):
+            parse_function_params_values(
+                values=values,
+                params_key="custom_oracle_params",
+                discriminator_key="custom_oracle",
+                param_classes={CustomFunction},
+                default_parser_class=CustomFunction,
+            )
         return values
 
-    @pydantic.validator("custom_oracle_params")
+    @pydantic.field_validator("custom_oracle_params")
+    @classmethod
     def _validate_names_match_oracle(
         cls, custom_oracle_params: CustomFunction
     ) -> CustomFunction:

classiq/interface/generator/piecewise_linear_amplitude_loading.py

@@ -2,6 +2,8 @@ import math
 from typing import Any, Dict, Generic, List, Sequence, Tuple, TypeVar
 
 import pydantic
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+from pydantic_core.core_schema import ValidationInfo
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
@@ -18,8 +20,8 @@ Breakpoint = TypeVar("Breakpoint")
 
 
 class AffineMap(HashablePydanticBaseModel):
-    slope: float = pydantic.Field(default=1.0)
-    offset: float = pydantic.Field(default=0.0)
+    slope: float = Field(default=1.0)
+    offset: float = Field(default=0.0)
 
     def evaluate(self, x: float) -> float:
         return self.offset + self.slope * x
@@ -27,16 +29,15 @@ class AffineMap(HashablePydanticBaseModel):
     def image_bounds(self, domain_bounds: Tuple[float, float]) -> Tuple[float, float]:
         return self.evaluate(domain_bounds[0]), self.evaluate(domain_bounds[1])
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
 
 class PiecewiseLinearAmplitudeLoadingABC(
-    FunctionParams, pydantic.generics.GenericModel, Generic[Breakpoint]
+    FunctionParams, BaseModel, Generic[Breakpoint]
 ):
-    num_qubits: pydantic.PositiveInt = pydantic.Field()
-    breakpoints: Sequence[pydantic.NonNegativeInt] = pydantic.Field()
-    affine_maps: Sequence[AffineMap] = pydantic.Field()
+    num_qubits: int = Field()
+    breakpoints: Sequence[int] = Field()
+    affine_maps: Sequence[AffineMap] = Field()
 
     def _create_ios(self) -> None:
         self._inputs = {
@@ -58,19 +59,35 @@ class PiecewiseLinearAmplitudeLoadingABC(
         top = max(max(piece) for piece in piece_bounds)
         return bottom, top
 
-    @pydantic.validator("breakpoints")
+    @field_validator("breakpoints", mode="before")
+    @classmethod
     def _validate_breakpoints(cls, breakpoints: Sequence[int]) -> Sequence[int]:
+        return cls.validate_breakpoints(breakpoints)
+
+    @classmethod
+    def validate_breakpoints(cls, breakpoints: Sequence[int]) -> Sequence[int]:
         assert len(breakpoints) == len(
             set(breakpoints)
         ), "Repeated breakpoints encountered"
         assert list(breakpoints) == sorted(breakpoints), "Breakpoints not sorted"
-        return breakpoints
+        return list(map(int, breakpoints))
 
-    @pydantic.root_validator(pre=True)
-    def _validate_lengths(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _validate_lengths(cls, values: Any) -> Dict[str, Any]:
         breakpoints = values.get("breakpoints", list())
         affine_maps = values.get("affine_maps", list())
         num_qubits = values.get("num_qubits", int)
+        if isinstance(values, dict):
+            breakpoints = values.get("breakpoints", list())
+            affine_maps = values.get("affine_maps", list())
+            num_qubits = values.get("num_qubits", int)
+        elif isinstance(values, PiecewiseLinearAmplitudeLoadingABC):
+            breakpoints = values.breakpoints
+            affine_maps = values.affine_maps
+            num_qubits = values.num_qubits
+            values = values.__dict__
+
         assert len(breakpoints) - 1 == len(
             affine_maps
         ), "Size mismatch between the number of slopes and breakpoints. The number of breakpoints should be the number of slopes + 1"
@@ -80,28 +97,27 @@ class PiecewiseLinearAmplitudeLoadingABC(
         return values
 
 
-class PiecewiseLinearRotationAmplitudeLoading(
-    PiecewiseLinearAmplitudeLoadingABC[pydantic.NonNegativeInt]
-):
+class PiecewiseLinearRotationAmplitudeLoading(PiecewiseLinearAmplitudeLoadingABC[int]):
     pass
 
-    @pydantic.validator("breakpoints")
-    def _validate_breakpoints(
-        cls, breakpoints: Sequence[int], values: Dict[str, Any]
+    @field_validator("breakpoints")
+    @classmethod
+    def _validate_breakpoints_field(
+        cls, breakpoints: Sequence[int], info: ValidationInfo
     ) -> Sequence[int]:
-        num_qubits = values.get("num_qubits")
+        num_qubits = info.data.get("num_qubits")
         assert isinstance(num_qubits, int), "Must have an integer number of qubits"
         assert min(breakpoints) == 0, "First breakpoint must be 0"
         assert (
             max(breakpoints) == 2**num_qubits - 1
         ), f"Last breakpoint must be {2**num_qubits - 1}"
-        return PiecewiseLinearAmplitudeLoadingABC._validate_breakpoints(
+        return PiecewiseLinearAmplitudeLoadingABC.validate_breakpoints(
             breakpoints=breakpoints
         )
 
 
 class PiecewiseLinearAmplitudeLoading(PiecewiseLinearAmplitudeLoadingABC[float]):
-    rescaling_factor: float = pydantic.Field(default=0.25 * math.pi)
+    rescaling_factor: float = Field(default=0.25 * math.pi)
 
     def rescaled(self) -> PiecewiseLinearRotationAmplitudeLoading:
         c, d = self._get_image_bounds()

classiq/interface/generator/qpe.py

@@ -1,6 +1,9 @@
 from typing import Any, Dict, Optional, Tuple
 
 import pydantic
+from pydantic import ConfigDict
+from pydantic_core.core_schema import ValidationInfo
+from typing_extensions import Self
 
 from classiq.interface.exceptions import ClassiqMismatchIOsError, ClassiqValueError
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
@@ -36,9 +39,7 @@ class ExponentiationScaling(pydantic.BaseModel):
         default=2.0,
         description="The scaling factor of the exponentiation max_depth; defaults to 2.",
     )
-
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
 
 class ExponentiationSpecification(pydantic.BaseModel):
@@ -55,17 +56,13 @@ class ExponentiationSpecification(pydantic.BaseModel):
         default=None,
         description="The max_depth of each exponentiation function; overrides scaling.",
     )
+    model_config = ConfigDict(frozen=True)
 
-    class Config:
-        frozen = True
-
-    @pydantic.root_validator
-    def _validate_exponentiation_specification(
-        cls, values: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        if values.get("scaling") is None and values.get("max_depths") is None:
+    @pydantic.model_validator(mode="after")
+    def _validate_exponentiation_specification(self) -> Self:
+        if self.scaling is None and self.max_depths is None:
             raise ClassiqValueError("At least one specification must be provided.")
-        return values
+        return self
 
 
 class PhaseEstimation(FunctionParams):
@@ -104,28 +101,42 @@ class PhaseEstimation(FunctionParams):
         self._outputs[self._output_name] = RegisterArithmeticInfo(size=self.size)
         self._create_zero_input_registers({DEFAULT_ZERO_NAME: self.size})
 
-    @pydantic.root_validator(pre=True)
-    def _validate_composite_name(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        if isinstance(values.get("unitary_params"), CustomFunction) and not values.get(
-            "unitary"
-        ):
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _validate_composite_name(cls, values: Any) -> Dict[str, Any]:
+        if not isinstance(values, dict):
+            return values
+        unitary_params = values.get("unitary_params")
+        unitary = values.get("unitary")
+
+        if isinstance(unitary_params, CustomFunction) and not unitary:
             raise ClassiqValueError(
                 "`PhaseEstimation` of a user define function (`CustomFunction`) must receive the function name from the `unitary` field"
             )
         return values
 
-    @pydantic.root_validator(pre=True)
-    def _parse_function_params(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _parse_function_params(
+        cls, values: Any, info: ValidationInfo
+    ) -> Dict[str, Any]:
+        vals = info.data.copy() if info.data else {}
+        if isinstance(values, dict):
+            vals = values
+        elif isinstance(values, PhaseEstimation):
+            vals = values.model_dump()
+
         parse_function_params_values(
-            values=values,
+            values=vals,
             params_key="unitary_params",
             discriminator_key="unitary",
             param_classes=function_param_library_without_self_reference.param_list,
             default_parser_class=CustomFunction,
         )
-        return values
+        return vals
 
-    @pydantic.validator("unitary_params")
+    @pydantic.field_validator("unitary_params")
+    @classmethod
     def _validate_unitary_params(cls, unitary_params: FunctionParams) -> FunctionParams:
         if not unitary_params.is_powerable():
             if isinstance(unitary_params, CustomFunction):
@@ -135,22 +146,23 @@ class PhaseEstimation(FunctionParams):
             )
         return unitary_params
 
-    @pydantic.validator("exponentiation_specification")
+    @pydantic.field_validator("exponentiation_specification")
+    @classmethod
     def _validate_exponentiation_specification(
         cls,
         exponentiation_specification: Optional[ExponentiationSpecification],
-        values: Dict[str, Any],
+        validation_info: ValidationInfo,
     ) -> Optional[ExponentiationSpecification]:
         if exponentiation_specification is None:
             return exponentiation_specification
-        unitary_params = values.get("unitary_params")
+        unitary_params = validation_info.data.get("unitary_params")
         if not isinstance(unitary_params, Exponentiation):
             raise ClassiqValueError(
                 "exponentiation_specification is only valid for Exponentiation unitary_params."
             )
         if exponentiation_specification.max_depths is not None and len(
             exponentiation_specification.max_depths
-        ) != values.get("size"):
+        ) != validation_info.data.get("size"):
             raise ClassiqValueError(
                 "Length of max_depths must match the provided size."
             )

classiq/interface/generator/qsvm.py

@@ -2,6 +2,7 @@ from typing import List, Literal, Optional, Union
 
 import numpy as np
 import pydantic
+from pydantic import ConfigDict
 
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.exceptions import ClassiqQSVMError, ClassiqValueError
@@ -28,9 +29,7 @@ class QSVMFeatureMapEntanglement(StrEnum):
 
 class QSVMFeatureMapDimensional(HashablePydanticBaseModel):
     feature_dimension: Optional[int] = None
-
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
 
 class QSVMFeatureMapPauli(QSVMFeatureMapDimensional):
@@ -42,7 +41,8 @@ class QSVMFeatureMapPauli(QSVMFeatureMapDimensional):
     parameter_prefix: str = "x"
     name: str = "PauliFeatureMap"
 
-    @pydantic.validator("paulis", pre=True)
+    @pydantic.field_validator("paulis", mode="before")
+    @classmethod
     def set_paulis(cls, paulis: List[str]) -> List[str]:
         # iterate every letter in every string in the list of paulis
         for s in paulis:

classiq/interface/generator/quantum_function_call.py

@@ -21,7 +21,8 @@ from typing import (
 from uuid import UUID, uuid4
 
 import pydantic
-from pydantic import BaseModel, Extra
+from pydantic import BaseModel, ConfigDict
+from pydantic_core.core_schema import ValidationInfo
 
 from classiq.interface.exceptions import ClassiqControlError, ClassiqValueError
 from classiq.interface.generator import function_param_list, function_params as f_params
@@ -146,10 +147,11 @@ class SynthesisQuantumFunctionCall(BaseModel):
     )
     name: PydanticNonEmptyString = pydantic.Field(
         default=None,
+        validate_default=True,
         description="The name of the function instance. "
         "If not set, determined automatically.",
     )
-    model_source_id: Optional[UUID] = pydantic.Field(default=None)
+    source_id: Optional[UUID] = pydantic.Field(default=None)
     arithmetic_id: Optional[str] = pydantic.Field(default=None)
     inverse_op_id: Optional[UUID] = pydantic.Field(default=None)
 
@@ -214,8 +216,9 @@ class SynthesisQuantumFunctionCall(BaseModel):
             return self.function_params.inputs_full(self.strict_zero_ios)
         return self.function_params.outputs
 
-    @pydantic.validator("name", pre=True, always=True)
-    def _create_name(cls, name: Optional[str], values: Dict[str, Any]) -> str:
+    @pydantic.field_validator("name", mode="before")
+    @classmethod
+    def _create_name(cls, name: Optional[str], info: ValidationInfo) -> str:
         """
         generates a name to a user defined-functions as follows:
         <function_name>_<SUFFIX_MARKER>_<random_suffix>
@@ -226,9 +229,9 @@ class SynthesisQuantumFunctionCall(BaseModel):
                 raise ClassiqValueError(BAD_CALL_NAME_ERROR_MSG)
             return name
 
-        function = values.get("function")
+        function = info.data.get("function")
 
-        params = values.get("function_params")
+        params = info.data.get("function_params")
         if (
             isinstance(params, CustomFunction)
             and function == CustomFunction.discriminator()
@@ -241,25 +244,30 @@ class SynthesisQuantumFunctionCall(BaseModel):
             return name if name else suffix
         return f"{function.split(f'_{EXPANDED_KEYWORD}')[0]}_{suffix}"
 
-    @pydantic.root_validator(pre=True)
-    def validate_composite_name(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        if isinstance(values.get("unitary_params"), CustomFunction) and not values.get(
-            "unitary"
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def validate_composite_name(cls, values: Any) -> Dict[str, Any]:
+        if (
+            isinstance(values, dict)
+            and isinstance(values.get("unitary_params"), CustomFunction)
+            and not values.get("unitary")
         ):
             raise ClassiqValueError(
                 "`PhaseEstimation` of a user define function (`CustomFunction`) must receive the function name from the `unitary` field"
             )
         return values
 
-    @pydantic.root_validator(pre=True)
-    def _parse_function_params(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        f_params.parse_function_params_values(
-            values=values,
-            params_key="function_params",
-            discriminator_key="function",
-            param_classes=function_param_list.function_param_library.param_list,
-            default_parser_class=CustomFunction,
-        )
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _parse_function_params(cls, values: Any) -> Dict[str, Any]:
+        if isinstance(values, dict):
+            f_params.parse_function_params_values(
+                values=values,
+                params_key="function_params",
+                discriminator_key="function",
+                param_classes=function_param_list.function_param_library.param_list,
+                default_parser_class=CustomFunction,
+            )
         return values
 
     # TODO: note that this checks QuantumFunctionCall input register names
@@ -295,22 +303,25 @@ class SynthesisQuantumFunctionCall(BaseModel):
         if error_msg:
             raise ClassiqValueError("\n".join(error_msg))
 
-    @pydantic.validator("strict_zero_ios")
+    @pydantic.field_validator("strict_zero_ios")
+    @classmethod
     def _validate_arithmetic_cannot_strict_zero_ios(
-        cls, strict_zero_ios: bool, values: Dict[str, Any]
+        cls, strict_zero_ios: bool, info: ValidationInfo
     ) -> bool:
         assert not (
-            values.get("function") == Arithmetic.discriminator() and not strict_zero_ios
+            info.data.get("function") == Arithmetic.discriminator()
+            and not strict_zero_ios
         ), "when using the Arithmetic function, assign to the expression result register via the target parameter instead of the strict_zero_ios flag"
         return strict_zero_ios
 
-    @pydantic.validator("control_states")
+    @pydantic.field_validator("control_states")
+    @classmethod
     def _validate_control_states(
-        cls, control_states: List[ControlState], values: Dict[str, Any]
+        cls, control_states: List[ControlState], info: ValidationInfo
     ) -> List[ControlState]:
         control_names = [ctrl_state.name for ctrl_state in control_states]
-        function_params = values.get("function_params")
-        strict_zero_ios = values.get("strict_zero_ios")
+        function_params = info.data.get("function_params")
+        strict_zero_ios = info.data.get("strict_zero_ios")
         if not (
             isinstance(function_params, FunctionParams)
             and isinstance(strict_zero_ios, bool)
@@ -382,12 +393,13 @@ class SynthesisQuantumFunctionCall(BaseModel):
 
         return not any((empty_slices, out_of_range, overlapping_slices))
 
-    @pydantic.validator("inputs")
-    def _validate_inputs(cls, inputs: IOType, values: Dict[str, Any]) -> WireDict:
-        params: Optional[FunctionParams] = values.get("function_params")
-        is_inverse: bool = values.get("is_inverse", False)
-        strict_zero_ios: bool = values.get("strict_zero_ios", True)
-        control_states: List[ControlState] = values.get("control_states", list())
+    @pydantic.field_validator("inputs", mode="before")
+    @classmethod
+    def _validate_inputs(cls, inputs: IOType, info: ValidationInfo) -> WireDict:
+        params: Optional[FunctionParams] = info.data.get("function_params")
+        is_inverse: bool = info.data.get("is_inverse", False)
+        strict_zero_ios: bool = info.data.get("strict_zero_ios", True)
+        control_states: List[ControlState] = info.data.get("control_states", list())
         if params is None:
             return dict()
         if isinstance(params, CustomFunction):
@@ -452,12 +464,13 @@ class SynthesisQuantumFunctionCall(BaseModel):
         if error_msg:
             raise ClassiqValueError("\n".join(error_msg))
 
-    @pydantic.validator("outputs")
-    def _validate_outputs(cls, outputs: IOType, values: Dict[str, Any]) -> IOType:
-        params = values.get("function_params")
-        is_inverse: bool = values.get("is_inverse", False)
-        strict_zero_ios: bool = values.get("strict_zero_ios", True)
-        control_states = values.get("control_states", list())
+    @pydantic.field_validator("outputs", mode="before")
+    @classmethod
+    def _validate_outputs(cls, outputs: IOType, info: ValidationInfo) -> IOType:
+        params = info.data.get("function_params")
+        is_inverse: bool = info.data.get("is_inverse", False)
+        strict_zero_ios: bool = info.data.get("strict_zero_ios", True)
+        control_states = info.data.get("control_states", list())
         if params is None:
             return outputs
         if isinstance(params, CustomFunction):
@@ -492,15 +505,16 @@ class SynthesisQuantumFunctionCall(BaseModel):
 
         return outputs
 
-    @pydantic.validator("power", always=True)
+    @pydantic.field_validator("power")
+    @classmethod
     def _validate_power(
-        cls, power: pydantic.NonNegativeInt, values: Dict[str, Any]
+        cls, power: pydantic.NonNegativeInt, info: ValidationInfo
     ) -> pydantic.NonNegativeInt:
-        function_params = values.get("function_params")
+        function_params = info.data.get("function_params")
         if function_params is None:
             return power
         if power != 1 and not function_params.is_powerable(
-            values.get("strict_zero_ios")
+            info.data.get("strict_zero_ios")
         ):
             raise ClassiqValueError("Cannot power this operator")
         return power
@@ -633,8 +647,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
         call_kwargs["control_states"] = self.control_states + [control_state]
         return SynthesisQuantumFunctionCall(**call_kwargs)
 
-    class Config:
-        extra = Extra.forbid
+    model_config = ConfigDict(extra="forbid")
 
 
 def _generate_single_io_err(