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

classiq/interface/generator/arith/binary_ops.py

@@ -14,7 +14,9 @@ from typing import (
 )
 
 import pydantic
-from pydantic.generics import GenericModel
+from pydantic import BaseModel
+from pydantic_core.core_schema import ValidationInfo
+from typing_extensions import Self
 
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.exceptions import ClassiqValueError
@@ -54,21 +56,24 @@ class ArgToInplace(StrEnum):
 
 
 class BinaryOpParams(
-    ArithmeticOperationParams, GenericModel, Generic[LeftDataT, RightDataT]
+    ArithmeticOperationParams, BaseModel, Generic[LeftDataT, RightDataT]
 ):
     left_arg: LeftDataT
     right_arg: RightDataT
     left_arg_name: ClassVar[str] = DEFAULT_LEFT_ARG_NAME
     right_arg_name: ClassVar[str] = DEFAULT_RIGHT_ARG_NAME
 
-    @pydantic.root_validator(pre=True)
-    def _clone_repeated_arg(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        left_arg = values.get("left_arg")
-        right_arg = values.get("right_arg")
-        if left_arg is right_arg and isinstance(left_arg, pydantic.BaseModel):
-            # In case both arguments refer to the same object, copy it.
-            # This prevents changes performed on one argument to affect the other.
-            values["right_arg"] = left_arg.copy(deep=True)
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _clone_repeated_arg(cls, values: Any) -> Dict[str, Any]:
+        if isinstance(values, dict):
+            left_arg = values.get("left_arg")
+            right_arg = values.get("right_arg")
+
+            if left_arg is right_arg and isinstance(left_arg, pydantic.BaseModel):
+                # In case both arguments refer to the same object, copy it.
+                # This prevents changes performed on one argument to affect the other.
+                values["right_arg"] = left_arg.model_copy(deep=True)
         return values
 
     def garbage_output_size(self) -> pydantic.NonNegativeInt:
@@ -106,19 +111,21 @@ class InplacableBinaryOpParams(
 ):
     inplace_arg: Optional[ArgToInplace] = None
 
-    @pydantic.root_validator(pre=True)
-    def _validate_inplace_arg(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        left_arg = values.get("left_arg")
-        right_arg = values.get("right_arg")
-        inplace_arg: Optional[ArgToInplace] = values.get("inplace_arg")
-        if inplace_arg == ArgToInplace.RIGHT and isinstance(right_arg, Numeric):
-            raise ClassiqValueError(
-                _NumericArgumentInplaceErrorMessage.format(right_arg)
-            )
-        elif inplace_arg == ArgToInplace.LEFT and isinstance(left_arg, Numeric):
-            raise ClassiqValueError(
-                _NumericArgumentInplaceErrorMessage.format(left_arg)
-            )
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _validate_inplace_arg(cls, values: Any) -> Dict[str, Any]:
+        if isinstance(values, dict):
+            left_arg = values.get("left_arg")
+            right_arg = values.get("right_arg")
+            inplace_arg: Optional[ArgToInplace] = values.get("inplace_arg")
+            if inplace_arg == ArgToInplace.RIGHT and isinstance(right_arg, Numeric):
+                raise ClassiqValueError(
+                    _NumericArgumentInplaceErrorMessage.format(right_arg)
+                )
+            elif inplace_arg == ArgToInplace.LEFT and isinstance(left_arg, Numeric):
+                raise ClassiqValueError(
+                    _NumericArgumentInplaceErrorMessage.format(left_arg)
+                )
         return values
 
     def _create_ios(self) -> None:
@@ -192,28 +199,28 @@ class InplacableBinaryOpParams(
             yield ArgToInplace.LEFT
 
     def get_params_inplace_options(self) -> Iterable["InplacableBinaryOpParams"]:
-        params_kwargs = self.copy().__dict__
+        params_kwargs = self.model_copy().__dict__
         for inplace_arg in self._get_binary_op_inplace_options():
             params_kwargs["inplace_arg"] = inplace_arg
             yield self.__class__(**params_kwargs)
 
 
 class BinaryOpWithIntInputs(BinaryOpParams[RegisterOrInt, RegisterOrInt]):
-    @pydantic.root_validator()
-    def validate_int_registers(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        left_arg = values.get("left_arg")
+    @pydantic.model_validator(mode="after")
+    def validate_int_registers(self) -> Self:
+        left_arg = self.left_arg
         is_left_arg_float_register = (
             isinstance(left_arg, RegisterArithmeticInfo)
             and left_arg.fraction_places > 0
         )
-        right_arg = values.get("right_arg")
+        right_arg = self.right_arg
         is_right_arg_float_register = (
             isinstance(right_arg, RegisterArithmeticInfo)
             and right_arg.fraction_places > 0
         )
         if is_left_arg_float_register or is_right_arg_float_register:
             raise ClassiqValueError(BOOLEAN_OP_WITH_FRACTIONS_ERROR)
-        return values
+        return self
 
     @staticmethod
     def _is_signed(arg: Union[int, RegisterArithmeticInfo]) -> bool:
@@ -344,11 +351,18 @@ class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
             argument_utils.fraction_places(self.effective_right_arg),
         )
 
+        size = self.output_size or self._get_output_size(bounds, fraction_places)
+        is_signed = self._include_sign and min(bounds) < 0
         return RegisterArithmeticInfo(
-            size=self.output_size or self._get_output_size(bounds, fraction_places),
+            size=size,
             fraction_places=fraction_places,
-            is_signed=self._include_sign and min(bounds) < 0,
-            bounds=self._legal_bounds(bounds),
+            is_signed=is_signed,
+            bounds=self._legal_bounds(
+                bounds,
+                RegisterArithmeticInfo.get_maximal_bounds(
+                    size=size, is_signed=is_signed, fraction_places=fraction_places
+                ),
+            ),
         )
 
     def _get_output_size(
@@ -492,12 +506,20 @@ class Multiplier(BinaryOpWithFloatInputs):
             )
             bounds = number_utils.bounds_cut(bounds, max_bounds)
 
+        size = self.output_size or self._get_output_size(
+            bounds, fraction_places, left_arg, right_arg
+        )
+        is_signed = self._include_sign and min(bounds) < 0
         return RegisterArithmeticInfo(
-            size=self.output_size
-            or self._get_output_size(bounds, fraction_places, left_arg, right_arg),
+            size=size,
             fraction_places=fraction_places,
-            is_signed=self._include_sign and min(bounds) < 0,
-            bounds=self._legal_bounds(bounds),
+            is_signed=is_signed,
+            bounds=self._legal_bounds(
+                bounds,
+                RegisterArithmeticInfo.get_maximal_bounds(
+                    size=size, is_signed=is_signed, fraction_places=fraction_places
+                ),
+            ),
         )
 
     @staticmethod
@@ -562,7 +584,8 @@ class LessEqual(Comparator):
 class Power(BinaryOpParams[RegisterArithmeticInfo, pydantic.PositiveInt]):
     output_name = "powered"
 
-    @pydantic.validator("right_arg", pre=True)
+    @pydantic.field_validator("right_arg", mode="before")
+    @classmethod
     def _validate_legal_power(cls, right_arg: Any) -> pydantic.PositiveInt:
         if not float(right_arg).is_integer():
             raise ClassiqValueError("Power must be an integer")
@@ -674,19 +697,19 @@ class LShift(EffectiveUnaryOpParams[pydantic.NonNegativeInt]):
     output_name = "left_shifted"
     inplace_arg: Optional[ArgToInplace] = ArgToInplace.LEFT
 
-    @pydantic.root_validator()
-    def _validate_legal_modulo(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        output_size = values.get("output_size")
+    @pydantic.model_validator(mode="after")
+    def _validate_legal_modulo(self) -> Self:
+        output_size = self.output_size
         if output_size is None:
-            return values
-        arg = values.get("left_arg")
-        shift = values.get("right_arg")
+            return self
+        arg = self.left_arg
+        shift = self.right_arg
         if not isinstance(arg, RegisterArithmeticInfo):
             raise ClassiqValueError("left arg must be a RegisterArithmeticInfo")
         if not isinstance(shift, int):
             raise ClassiqValueError("Shift must be an integer")
         assert arg.fraction_places - shift <= 0, _FLOATING_POINT_MODULO_ERROR_MESSAGE
-        return values
+        return self
 
     def garbage_output_size(self) -> pydantic.NonNegativeInt:
         if self.inplace_arg is None or self.output_size is None:
@@ -715,21 +738,21 @@ class RShift(EffectiveUnaryOpParams[pydantic.NonNegativeInt]):
     def _shifted_fraction_places(*, arg: RegisterArithmeticInfo, shift: int) -> int:
         return arg.fraction_places * int(arg.is_signed or shift < arg.size)
 
-    @pydantic.root_validator()
-    def _validate_legal_modulo(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        output_size = values.get("output_size")
+    @pydantic.model_validator(mode="after")
+    def _validate_legal_modulo(self) -> Self:
+        output_size = self.output_size
         if output_size is None:
-            return values
-        arg = values.get("left_arg")
-        shift = values.get("right_arg")
+            return self
+        arg = self.left_arg
+        shift = self.right_arg
         if not isinstance(arg, RegisterArithmeticInfo):
             raise ClassiqValueError("left arg must be a RegisterArithmeticInfo")
         if not isinstance(shift, int):
             raise ClassiqValueError("Shift must be an integer")
         assert (
-            cls._shifted_fraction_places(arg=arg, shift=shift) == 0
+            self._shifted_fraction_places(arg=arg, shift=shift) == 0
         ), _FLOATING_POINT_MODULO_ERROR_MESSAGE
-        return values
+        return self
 
     def garbage_output_size(self) -> pydantic.NonNegativeInt:
         if self.inplace_arg is None:
@@ -759,16 +782,16 @@ class CyclicShift(EffectiveUnaryOpParams[int]):
     output_name = "cyclic_shifted"
     inplace_arg: Optional[ArgToInplace] = ArgToInplace.LEFT
 
-    @pydantic.root_validator()
-    def _validate_legal_modulo(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        output_size = values.get("output_size")
+    @pydantic.model_validator(mode="after")
+    def _validate_legal_modulo(self) -> Self:
+        output_size = self.output_size
         if output_size is None:
-            return values
-        arg = values.get("left_arg")
+            return self
+        arg = self.left_arg
         if not isinstance(arg, RegisterArithmeticInfo):
             raise ClassiqValueError("left arg must be a RegisterArithmeticInfo")
         assert arg.fraction_places == 0, _FLOATING_POINT_MODULO_ERROR_MESSAGE
-        return values
+        return self
 
     def garbage_output_size(self) -> pydantic.NonNegativeInt:
         if self.inplace_arg is None:
@@ -787,24 +810,26 @@ class Modulo(EffectiveUnaryOpParams[int]):
     output_name = "modulus"
     inplace_arg: Optional[ArgToInplace] = ArgToInplace.LEFT
 
-    @pydantic.validator("left_arg")
+    @pydantic.field_validator("left_arg", mode="before")
+    @classmethod
     def _validate_left_arg_is_integer(
         cls, left_arg: RegisterArithmeticInfo
     ) -> RegisterArithmeticInfo:
         assert left_arg.fraction_places == 0, _FLOATING_POINT_MODULO_ERROR_MESSAGE
         return left_arg
 
-    @pydantic.validator("right_arg")
+    @pydantic.field_validator("right_arg", mode="before")
+    @classmethod
     def _validate_right_arg_is_a_power_of_two(
-        cls, right_arg: int, values: Dict[str, Any]
+        cls, right_arg: int, info: ValidationInfo
     ) -> int:
         repr_qubits_float = math.log2(right_arg)
         repr_qubits = round(repr_qubits_float)
         assert abs(repr_qubits - repr_qubits_float) < 10**-8, NOT_POWER_OF_TWO_ERROR_MSG
-        output_size = values.get("output_size")
+        output_size = info.data.get("output_size")
         if output_size is not None:
             repr_qubits = min(repr_qubits, output_size)
-        values["output_size"] = None
+        info.data["output_size"] = None
         return 2 ** (repr_qubits)
 
     def _get_result_register(self) -> RegisterArithmeticInfo:

classiq/interface/generator/arith/extremum_operations.py

@@ -24,16 +24,18 @@ class Extremum(ArithmeticOperationParams):
     left_arg: RegisterOrConst
     right_arg: RegisterOrConst
 
-    @pydantic.root_validator(pre=True)
-    def _validate_one_is_register(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        left_arg = values.get("left_arg")
-        right_arg = values.get("right_arg")
-        if isinstance(left_arg, Numeric) and isinstance(right_arg, Numeric):
-            raise ClassiqValueError("One argument must be a register")
-        if left_arg is right_arg and isinstance(left_arg, pydantic.BaseModel):
-            # In case both arguments refer to the same object, copy it.
-            # This prevents changes performed on one argument from affecting the other.
-            values["right_arg"] = left_arg.copy(deep=True)
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _validate_one_is_register(cls, values: Any) -> Dict[str, Any]:
+        if isinstance(values, dict):
+            left_arg = values.get("left_arg")
+            right_arg = values.get("right_arg")
+            if isinstance(left_arg, Numeric) and isinstance(right_arg, Numeric):
+                raise ClassiqValueError("One argument must be a register")
+            if left_arg is right_arg and isinstance(left_arg, pydantic.BaseModel):
+                # In case both arguments refer to the same object, copy it.
+                # This prevents changes performed on one argument from affecting the other.
+                values["right_arg"] = left_arg.model_copy(deep=True)
         return values
 
     def _create_ios(self) -> None:
@@ -116,11 +118,18 @@ class Extremum(ArithmeticOperationParams):
                 size=self.output_size, is_signed=False, fraction_places=0
             )
             bounds = number_utils.bounds_cut(bounds, max_bounds)
+        size = self.output_size or required_size
+        is_signed = self._include_sign and min(bounds) < 0
         return RegisterArithmeticInfo(
-            size=self.output_size or required_size,
+            size=size,
             fraction_places=fraction_places,
-            is_signed=self._include_sign and min(bounds) < 0,
-            bounds=self._legal_bounds(bounds),
+            is_signed=is_signed,
+            bounds=self._legal_bounds(
+                bounds,
+                RegisterArithmeticInfo.get_maximal_bounds(
+                    size=size, is_signed=is_signed, fraction_places=fraction_places
+                ),
+            ),
         )
 
 

classiq/interface/generator/arith/logical_ops.py

@@ -1,6 +1,7 @@
 from typing import Iterable, List, Optional
 
 import pydantic
+from pydantic import ConfigDict
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.argument_utils import RegisterOrConst
@@ -23,13 +24,15 @@ class LogicalOps(ArithmeticOperationParams):
     def update_should_invert_node_list(self, invert_args: List[str]) -> None:
         self._should_invert_node_list.extend(invert_args)
 
-    @pydantic.validator("output_size")
+    @pydantic.field_validator("output_size")
+    @classmethod
     def _validate_output_size(cls, output_size: Optional[int]) -> int:
         if output_size is not None and output_size != 1:
             raise ClassiqValueError("logical operation output size must be 1")
         return 1
 
-    @pydantic.validator("args")
+    @pydantic.field_validator("args")
+    @classmethod
     def _validate_inputs_sizes(
         cls, arguments: List[RegisterOrConst]
     ) -> List[RegisterOrConst]:
@@ -64,8 +67,7 @@ class LogicalOps(ArithmeticOperationParams):
     def get_params_inplace_options(self) -> Iterable["LogicalOps"]:
         return ()
 
-    class Config:
-        arbitrary_types_allowed = True
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
 
 class LogicalAnd(LogicalOps):

classiq/interface/generator/arith/number_utils.py

@@ -12,7 +12,7 @@ def signed_int_to_unsigned(number: int) -> int:
     return number + 2 ** (number.bit_length() + 1 * not_power2)
 
 
-def _binary_to_int(bin_rep: str, is_signed: bool) -> int:
+def binary_to_int(bin_rep: str, is_signed: bool = False) -> int:
     negative_offset: int = -(2 ** len(bin_rep)) * (bin_rep[0] == "1") * is_signed
     return int(bin_rep, 2) + negative_offset
 
@@ -20,14 +20,14 @@ def _binary_to_int(bin_rep: str, is_signed: bool) -> int:
 def binary_to_float(
     bin_rep: str, fraction_part_size: int = 0, is_signed: bool = False
 ) -> float:
-    return _binary_to_int(bin_rep, is_signed) / 2**fraction_part_size
+    return binary_to_int(bin_rep, is_signed) / 2**fraction_part_size
 
 
 def binary_to_float_or_int(
     bin_rep: str, fraction_part_size: int = 0, is_signed: bool = False
 ) -> Union[float, int]:
     if fraction_part_size == 0:
-        return _binary_to_int(bin_rep, is_signed)
+        return binary_to_int(bin_rep, is_signed)
     return binary_to_float(bin_rep, fraction_part_size, is_signed)
 
 

classiq/interface/generator/arith/register_user_input.py

@@ -1,6 +1,8 @@
 from typing import Any, Dict, Optional, Tuple
 
 import pydantic
+from pydantic import ConfigDict
+from pydantic_core.core_schema import ValidationInfo
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith import number_utils
@@ -11,16 +13,28 @@ from classiq.interface.helpers.hashable_pydantic_base_model import (
 
 
 class RegisterArithmeticInfo(HashablePydanticBaseModel):
-    size: pydantic.PositiveInt
+    size: pydantic.PositiveInt = pydantic.Field(default=1)
     is_signed: bool = pydantic.Field(default=False)
     fraction_places: pydantic.NonNegativeInt = pydantic.Field(default=0)
     bypass_bounds_validation: bool = pydantic.Field(default=False)
-    bounds: PydanticFloatTuple = pydantic.Field(default=None)
+    bounds: PydanticFloatTuple = pydantic.Field(
+        default=None,
+        validate_default=True,
+    )
 
-    @pydantic.root_validator(pre=True)
-    def _remove_name(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        if "name" in values:
-            values.pop("name")
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _remove_name(cls, values: Any, info: ValidationInfo) -> Dict[str, Any]:
+        if isinstance(values, dict):
+            values = values.copy()
+        elif hasattr(values, "__dict__"):
+            values = values.__dict__.copy()
+        elif values is None and info.data:
+            values = info.data.copy()
+        else:
+            raise ValueError("Unsupported type for removing 'name'.")
+
+        values.pop("name", None)
         return values
 
     @staticmethod
@@ -32,13 +46,14 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
         fraction_factor = float(2**-fraction_places)
         return (lb * fraction_factor, ub * fraction_factor)
 
-    @pydantic.validator("bounds", always=True)
+    @pydantic.field_validator("bounds", mode="before")
+    @classmethod
     def _validate_bounds(
-        cls, bounds: Optional[PydanticFloatTuple], values: Dict[str, Any]
+        cls, bounds: Optional[PydanticFloatTuple], info: ValidationInfo
     ) -> PydanticFloatTuple:
-        size = values.get("size")
-        is_signed = values.get("is_signed", False)
-        fraction_places = values.get("fraction_places", 0)
+        size = info.data.get("size")
+        is_signed = info.data.get("is_signed", False)
+        fraction_places = info.data.get("fraction_places", 0)
         if not isinstance(size, int):
             raise ClassiqValueError("RegisterArithmeticInfo must have an integer size")
 
@@ -52,7 +67,7 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
             number_utils.limit_fraction_places(min(bounds), fraction_places),
             number_utils.limit_fraction_places(max(bounds), fraction_places),
         )
-        if not values.get("bypass_bounds_validation", False):
+        if not info.data.get("bypass_bounds_validation", False):
             assert min(trimmed_bounds) >= min(maximal_bounds), "Illegal bound min"
             assert max(trimmed_bounds) <= max(maximal_bounds), "Illegal bound max"
         return trimmed_bounds
@@ -79,8 +94,7 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
     def integer_part_size(self) -> pydantic.NonNegativeInt:
         return self.size - self.fraction_places
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
 
 class RegisterUserInput(RegisterArithmeticInfo):
@@ -90,12 +104,13 @@ class RegisterUserInput(RegisterArithmeticInfo):
         super().__init__(**data)
         self._fields_to_skip_in_hash = frozenset({"name"})
 
-    @pydantic.root_validator(pre=True)
-    def _remove_name(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _remove_name(cls, values: Any, info: ValidationInfo) -> Dict[str, Any]:
         return values
 
     def revalued(self, **kwargs: Any) -> "RegisterUserInput":
-        return self.copy(update=kwargs)
+        return self.model_copy(update=kwargs)
 
     @classmethod
     def from_arithmetic_info(

classiq/interface/generator/arith/unary_ops.py

@@ -1,6 +1,7 @@
 from typing import TYPE_CHECKING, Final, Iterable, Optional
 
 import pydantic
+from pydantic import ConfigDict
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith import argument_utils, number_utils
@@ -52,12 +53,11 @@ class UnaryOpParams(ArithmeticOperationParams):
         return self.inplace
 
     def get_params_inplace_options(self) -> Iterable["UnaryOpParams"]:
-        params_kwargs = self.copy().__dict__
+        params_kwargs = self.model_copy().model_dump()
         params_kwargs["inplace"] = True
         yield self.__class__(**params_kwargs)
 
-    class Config:
-        arbitrary_types_allowed = True
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
 
 class BitwiseInvert(UnaryOpParams):
@@ -119,7 +119,8 @@ class Negation(UnaryOpParams):
 class Sign(UnaryOpParams):
     output_name = "sign"
 
-    @pydantic.validator("output_size")
+    @pydantic.field_validator("output_size")
+    @classmethod
     def _validate_output_size(
         cls, output_size: Optional[pydantic.PositiveInt]
     ) -> pydantic.PositiveInt:

classiq/interface/generator/chemistry_function_params.py

@@ -16,7 +16,8 @@ from classiq.interface.generator.function_params import (
 class ChemistryFunctionParams(FunctionParams):
     gs_problem: CHEMISTRY_PROBLEMS_TYPE
 
-    @pydantic.validator("gs_problem")
+    @pydantic.field_validator("gs_problem")
+    @classmethod
     def validate_gs_problem_contains_num_qubits(
         cls, gs_problem: CHEMISTRY_PROBLEMS_TYPE
     ) -> CHEMISTRY_PROBLEMS_TYPE:

classiq/interface/generator/circuit_code/circuit_code.py

@@ -18,7 +18,8 @@ class CircuitCodeInterface(pydantic.BaseModel):
     outputs: Dict[QuantumFormat, Code]
     qasm_version: QasmVersion
 
-    @pydantic.validator("outputs")
+    @pydantic.field_validator("outputs")
+    @classmethod
     def reformat_long_string_output_formats(
         cls, outputs: Dict[QuantumFormat, str]
     ) -> Dict[QuantumFormat, LongStr]:

classiq/interface/generator/commuting_pauli_exponentiation.py

@@ -8,8 +8,8 @@ from classiq.interface.generator.function_params import (
     DEFAULT_INPUT_NAME,
     DEFAULT_OUTPUT_NAME,
     FunctionParams,
+    FunctionParamsNumericParameter,
 )
-from classiq.interface.generator.parameters import ParameterFloatType
 
 
 class CommutingPauliExponentiation(FunctionParams):
@@ -20,17 +20,18 @@ class CommutingPauliExponentiation(FunctionParams):
     pauli_operator: PauliOperator = pydantic.Field(
         description="A weighted sum of Pauli strings."
     )
-    evolution_coefficient: ParameterFloatType = pydantic.Field(
+    evolution_coefficient: FunctionParamsNumericParameter = pydantic.Field(
         default=1.0,
         description="A global coefficient multiplying the operator.",
-        is_exec_param=True,
     )
 
-    @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)
 
-    @pydantic.validator("pauli_operator")
+    @pydantic.field_validator("pauli_operator")
+    @classmethod
     def _validate_paulis_commute(cls, pauli_operator: PauliOperator) -> PauliOperator:
         if not pauli_operator.is_commutative:
             raise ClassiqValueError("Pauli strings are not commutative")

classiq/interface/generator/complex_type.py

@@ -1,23 +1,19 @@
-from typing import Any, Callable, Dict, Iterator
+from typing import Union
 
-from typing_extensions import Self
+from pydantic import PlainSerializer, PlainValidator
+from pydantic.json_schema import WithJsonSchema
+from typing_extensions import Annotated
 
 
-# Use this class as a type for complex data from the json, e.g., in the state_propagator function.
-class Complex(complex):
-    @classmethod
-    def __get_validators__(cls) -> Iterator[Callable]:
-        yield cls.validate
+def validate_complex(v: Union[complex, str]) -> complex:
+    if isinstance(v, str):
+        v = "".join(v.split())
+    return complex(v)
 
-    @classmethod
-    def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
-        field_schema.update(
-            pattern=r"[+-]?\d+\.?\d* *[+-] *\d+\.?\d*j",
-        )
 
-    @classmethod
-    def validate(cls, v: Any) -> Self:
-        if isinstance(v, str):
-            v = "".join(v.split())
-
-        return cls(v)
+Complex = Annotated[
+    complex,
+    PlainValidator(validate_complex),
+    PlainSerializer(lambda x: str(x)),
+    WithJsonSchema({"type": "string", "pattern": r"[+-]?\d+\.?\d* *[+-] *\d+\.?\d*j"}),
+]