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

classiq/interface/generator/functions/function_declaration.py

@@ -1,26 +1,25 @@
 import abc
-from typing import Dict
+from collections.abc import Sequence
 
-import pydantic
-from pydantic.main import BaseModel
+from pydantic import ConfigDict
 
-from classiq.interface.generator.functions.classical_type import ConcreteClassicalType
+from classiq.interface.model.classical_parameter_declaration import (
+    AnonClassicalParameterDeclaration,
+)
+from classiq.interface.model.parameter import Parameter
 
 
-class FunctionDeclaration(BaseModel, abc.ABC):
+class FunctionDeclaration(Parameter, abc.ABC):
     """
     Facilitates the creation of a common function interface object.
     """
 
-    name: str = pydantic.Field(description="The name of the function")
+    @property
+    @abc.abstractmethod
+    def param_decls(self) -> Sequence["AnonClassicalParameterDeclaration"]:
+        pass
 
-    param_decls: Dict[str, ConcreteClassicalType] = pydantic.Field(
-        description="The expected interface of the functions parameters",
-        default_factory=dict,
-    )
+    model_config = ConfigDict(extra="forbid")
 
-    class Config:
-        extra = pydantic.Extra.forbid
 
-
-FunctionDeclaration.update_forward_refs()
+FunctionDeclaration.model_rebuild()

classiq/interface/generator/functions/port_declaration.py

@@ -1,12 +1,8 @@
 from typing import Any
 
-import pydantic
-from pydantic import BaseModel
-
+from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.function_params import PortDirection
 
-from classiq._internals.enum_utils import StrEnum
-
 
 class PortDeclarationDirection(StrEnum):
     Input = "input"
@@ -39,11 +35,3 @@ class PortDeclarationDirection(StrEnum):
         cls, port_direction: PortDirection
     ) -> "PortDeclarationDirection":
         return cls(port_direction.value)
-
-
-class SynthesisPortDeclaration(BaseModel):
-    name: str
-    size: int
-    direction: PortDeclarationDirection
-    is_signed: bool = pydantic.Field(default=False)
-    fraction_places: int = pydantic.Field(default=0)

classiq/interface/generator/functions/qmod_python_interface.py

@@ -1,3 +1,4 @@
-from typing import Any, Mapping
+from collections.abc import Mapping
+from typing import Any
 
 QmodPyStruct = Mapping[str, Any]

classiq/interface/generator/functions/type_name.py

@@ -0,0 +1,90 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Literal, Optional
+
+import pydantic
+
+from classiq.interface.exceptions import ClassiqInternalError
+from classiq.interface.generator.expressions.qmod_qstruct_proxy import QmodQStructProxy
+from classiq.interface.generator.functions.classical_type import (
+    ClassicalType,
+)
+from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.quantum_type import (
+    QuantumType,
+)
+
+if TYPE_CHECKING:
+    from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
+
+
+class TypeName(ClassicalType, QuantumType):
+    kind: Literal["struct_instance"]
+    name: str = pydantic.Field(description="The type name of the instance")
+    _assigned_fields: Optional[Mapping[str, "ConcreteQuantumType"]] = (
+        pydantic.PrivateAttr(default=None)
+    )
+
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
+        return values_with_discriminator(values, "kind", "struct_instance")
+
+    def _update_size_in_bits_from_declaration(self) -> None:
+        fields_types = list(self.fields.values())
+        for field_type in fields_types:
+            field_type._update_size_in_bits_from_declaration()
+        if all(field_type.has_size_in_bits for field_type in fields_types):
+            self._size_in_bits = sum(
+                field_type.size_in_bits for field_type in fields_types
+            )
+
+    def get_proxy(self, handle: "HandleBinding") -> "QmodQStructProxy":
+        from classiq.interface.generator.expressions.qmod_qstruct_proxy import (
+            QmodQStructProxy,
+        )
+
+        return QmodQStructProxy(
+            handle=handle, struct_name=self.name, fields=self.fields
+        )
+
+    @property
+    def qmod_type_name(self) -> str:
+        return self.name
+
+    @property
+    def type_name(self) -> str:
+        return self.name
+
+    @property
+    def fields(self) -> Mapping[str, "ConcreteQuantumType"]:
+        if self._assigned_fields is None:
+            raise ClassiqInternalError("Fields not set")
+        return self._assigned_fields
+
+    @property
+    def has_fields(self) -> bool:
+        return self._assigned_fields is not None
+
+    def set_fields(self, fields: Mapping[str, "ConcreteQuantumType"]) -> None:
+        self._assigned_fields = fields
+
+    @property
+    def is_instantiated(self) -> bool:
+        return self.has_fields and all(
+            field_type.is_instantiated for field_type in self.fields.values()
+        )
+
+    @property
+    def is_evaluated(self) -> bool:
+        return self.has_fields and all(
+            field_type.is_evaluated for field_type in self.fields.values()
+        )
+
+
+class Enum(TypeName):
+    pass
+
+
+class Struct(TypeName):
+    pass

classiq/interface/generator/generated_circuit_data.py

@@ -1,17 +1,26 @@
-from typing import Dict, List, Literal, Optional, Tuple, Union
+import logging
+from typing import Literal, Optional, Union
 
 import pydantic
+from pydantic import ConfigDict
 from typing_extensions import TypeAlias
 
+from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.control_state import ControlState
 from classiq.interface.generator.register_role import RegisterRole
 from classiq.interface.generator.synthesis_metadata.synthesis_execution_data import (
     ExecutionData,
 )
 
-ParameterName = str
-IOQubitMapping: TypeAlias = Dict[str, Tuple[int, ...]]
+from classiq.model_expansions.capturing.mangling_utils import (
+    demangle_capture_name,
+    demangle_name,
+    is_captured_var_name,
+)
 
+_logger = logging.getLogger(__name__)
+ParameterName = str
+IOQubitMapping: TypeAlias = dict[str, tuple[int, ...]]
 
 CLASSIQ_HIERARCHY_SEPARATOR: Literal["."] = "."
 
@@ -21,7 +30,7 @@ VISUALIZATION_HIDE_LIST = [
     "control",
     "mcx",
     "iteration",
-    "operand",
+    "stmt_block",
 ]
 
 
@@ -39,8 +48,8 @@ class QubitMapping(pydantic.BaseModel):
 class GeneratedRegister(pydantic.BaseModel):
     name: str
     role: RegisterRole
-    qubit_indexes_relative: List[int]
-    qubit_indexes_absolute: List[int]
+    qubit_indexes_relative: list[int]
+    qubit_indexes_absolute: list[int]
 
     def __len__(self) -> int:
         return self.qubit_indexes_relative.__len__()
@@ -49,16 +58,25 @@ class GeneratedRegister(pydantic.BaseModel):
     def width(self) -> int:
         return len(self)
 
+    @property
+    def is_captured(self) -> bool:
+        return is_captured_var_name(self.name)
+
+    @staticmethod
+    def demangle_name(name: str) -> str:
+        if is_captured_var_name(name):
+            return demangle_capture_name(name)
+        return demangle_name(name)
+
 
 class GeneratedFunction(pydantic.BaseModel):
     name: str
-    control_states: List[ControlState]
-    registers: List[GeneratedRegister] = list()
-    depth: Optional[int]
-    width: Optional[int]
-    released_auxiliary_qubits: List[int] = list()
-    dangling_inputs: Dict[str, GeneratedRegister] = dict()
-    dangling_outputs: Dict[str, GeneratedRegister] = dict()
+    control_states: list[ControlState]
+    registers: list[GeneratedRegister] = list()
+    depth: Optional[int] = pydantic.Field(default=None)
+    width: Optional[int] = pydantic.Field(default=None)
+    dangling_inputs: dict[str, GeneratedRegister] = dict()
+    dangling_outputs: dict[str, GeneratedRegister] = dict()
 
     def __getitem__(self, key: Union[int, str]) -> GeneratedRegister:
         if isinstance(key, int):
@@ -85,7 +103,7 @@ class GeneratedFunction(pydantic.BaseModel):
 
 class GeneratedCircuitData(pydantic.BaseModel):
     width: int
-    circuit_parameters: List[ParameterName] = pydantic.Field(default_factory=list)
+    circuit_parameters: list[ParameterName] = pydantic.Field(default_factory=list)
     qubit_mapping: QubitMapping = pydantic.Field(default_factory=QubitMapping)
     execution_data: Optional[ExecutionData] = pydantic.Field(default=None)
 
@@ -94,13 +112,42 @@ class GeneratedCircuitData(pydantic.BaseModel):
         return cls(width=0)
 
 
-class FunctionDebugInfo(pydantic.BaseModel):
-    generated_function: Optional[GeneratedFunction]
-    children: List["FunctionDebugInfo"]
-    relative_qubits: Tuple[int, ...]
+class OperationLevel(StrEnum):
+    QMOD_FUNCTION_CALL = "QMOD_CALL"
+    QMOD_STATEMENT = "QMOD_STATEMENT"
+    ENGINE_FUNCTION_CALL = "ENGINE_CALL"
+    UNKNOWN = "UNKNOWN"
+
+
+class OperationParameter(pydantic.BaseModel):
+    label: str
+    value: Optional[str] = None
+
+
+class FunctionDebugInfoInterface(pydantic.BaseModel):
+    generated_function: Optional[GeneratedFunction] = pydantic.Field(default=None)
+    children: list["FunctionDebugInfoInterface"]
+    relative_qubits: tuple[int, ...]
+    absolute_qubits: Optional[tuple[int, ...]] = pydantic.Field(default=None)
+    is_basis_gate: Optional[bool] = pydantic.Field(default=None)
+    is_inverse: bool = pydantic.Field(default=False)
+    is_allocate_or_free: bool = pydantic.Field(default=False)
+    level: OperationLevel = pydantic.Field(default=OperationLevel.UNKNOWN)
+    parameters: list[OperationParameter] = list()
+    port_to_passed_variable_map: dict[str, str] = pydantic.Field(default={})
+
+    model_config = ConfigDict(extra="allow")
+    # Temporary field to store the override debug info for parallel old/new visualization
+    override_debug_info: Optional["FunctionDebugInfoInterface"] = None
 
     @property
-    def registers(self) -> List[GeneratedRegister]:
+    def name(self) -> str:
+        if self.generated_function is None:
+            return ""
+        return self.generated_function.name
+
+    @property
+    def registers(self) -> list[GeneratedRegister]:
         if self.generated_function is None:
             return list()
         return self.generated_function.registers
@@ -112,7 +159,93 @@ class FunctionDebugInfo(pydantic.BaseModel):
         return len(self.generated_function.control_states) > 0
 
     @property
-    def control_states(self) -> List[ControlState]:
+    def control_states(self) -> list[ControlState]:
         if self.generated_function is None:
             return list()
         return self.generated_function.control_states
+
+    @staticmethod
+    def create_parameters_from_dict(
+        parameters: dict[str, str]
+    ) -> list[OperationParameter]:
+        return [
+            OperationParameter(label=key, value=value)
+            for key, value in parameters.items()
+        ]
+
+    def propagate_absolute_qubits(self) -> "FunctionDebugInfoInterface":
+        if self.absolute_qubits is None:
+            return self
+
+        updated_registers = [
+            register.model_copy(
+                update=dict(
+                    qubit_indexes_absolute=list(
+                        _get_absolute_from_relative(
+                            self.absolute_qubits, tuple(register.qubit_indexes_relative)
+                        )
+                    )
+                )
+            )
+            for register in self.registers
+        ]
+        updated_generated_function = (
+            self.generated_function.model_copy(update=dict(registers=updated_registers))
+            if self.generated_function
+            else None
+        )
+
+        updated_children: list[FunctionDebugInfoInterface] = []
+        for child in self.children:
+            updated_child = child.white_new_absolute_qubits(self.absolute_qubits)
+            if updated_child.override_debug_info is None:
+                updated_child = updated_child.propagate_absolute_qubits()
+            else:
+                updated_child.override_debug_info = (
+                    updated_child.override_debug_info.white_new_absolute_qubits(
+                        absolute_qubits=self.absolute_qubits
+                    ).propagate_absolute_qubits()
+                )
+            updated_children.append(updated_child)
+
+        return self.model_copy(
+            update=dict(
+                generated_function=updated_generated_function,
+                children=updated_children,
+            )
+        )
+
+    def white_new_absolute_qubits(
+        self, absolute_qubits: tuple[int, ...]
+    ) -> "FunctionDebugInfoInterface":
+        return self.model_copy(
+            update=dict(
+                absolute_qubits=_get_absolute_from_relative(
+                    absolute_qubits, self.relative_qubits
+                )
+            )
+        )
+
+    def inverse(self) -> "FunctionDebugInfoInterface":
+        inverted_children = [child.inverse() for child in self.children[::-1]]
+        return self.model_copy(
+            update=dict(
+                is_inverse=not self.is_inverse,
+                children=inverted_children,
+            )
+        )
+
+
+def _get_absolute_from_relative(
+    absolute_qubits: tuple[int, ...], relative_qubits: tuple[int, ...]
+) -> tuple[int, ...]:
+    if len(relative_qubits) == 0:
+        return tuple()
+    if max(relative_qubits) >= len(absolute_qubits):
+        _logger.warning(
+            "Invalid qubit computation (relative qubits: %s, absolute qubits: %s)",
+            relative_qubits,
+            absolute_qubits,
+        )
+        return tuple()
+    return tuple(absolute_qubits[relative_qubit] for relative_qubit in relative_qubits)

classiq/interface/generator/grover_diffuser.py

@@ -1,7 +1,9 @@
-from typing import Any, Dict, List, Set, Tuple, Union
+from typing import Any, Union
 
 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
 from classiq.interface.generator.function_params import (
     ArithmeticIODict,
@@ -11,13 +13,11 @@ from classiq.interface.generator.function_params import (
 from classiq.interface.generator.state_preparation import StatePreparation
 from classiq.interface.generator.user_defined_function_params import CustomFunction
 
-from classiq.exceptions import ClassiqValueError
-
 GroverStatePreparation = Union[StatePreparation, CustomFunction]
 
 
 class GroverDiffuser(FunctionParams):
-    variables: List[RegisterUserInput]
+    variables: list[RegisterUserInput]
     state_preparation: str = pydantic.Field(
         default="", description="State preparation function"
     )
@@ -30,40 +30,47 @@ class GroverDiffuser(FunctionParams):
         self._inputs = {reg.name: reg for reg in self.variables}
         self._outputs = {reg.name: reg for reg in self.variables}
 
-    @pydantic.root_validator(pre=True)
-    def _validate_state_preparation_name(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        if isinstance(
-            values.get("state_preparation_params"), CustomFunction
-        ) and not values.get("state_preparation"):
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _validate_state_preparation_name(cls, values: Any) -> dict[str, Any]:
+        if (
+            isinstance(values, dict)
+            and isinstance(values.get("state_preparation_params"), CustomFunction)
+            and not values.get("state_preparation")
+        ):
             raise ClassiqValueError(
                 "Must receive the function name from the `state_preparation` field for user defined functions"
             )
         return values
 
-    @pydantic.root_validator(pre=True)
-    def _parse_state_preparation(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        parse_function_params_values(
-            values=values,
-            params_key="state_preparation_params",
-            discriminator_key="state_preparation",
-            param_classes={StatePreparation, CustomFunction},
-            default_parser_class=CustomFunction,
-        )
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _parse_state_preparation(cls, values: Any) -> dict[str, Any]:
+        if isinstance(values, dict):
+            parse_function_params_values(
+                values=values,
+                params_key="state_preparation_params",
+                discriminator_key="state_preparation",
+                param_classes={StatePreparation, CustomFunction},
+                default_parser_class=CustomFunction,
+            )
         return values
 
-    @pydantic.validator("variables")
+    @pydantic.field_validator("variables")
+    @classmethod
     def _validate_variables(
-        cls, variables: List[RegisterUserInput]
-    ) -> List[RegisterUserInput]:
+        cls, variables: list[RegisterUserInput]
+    ) -> list[RegisterUserInput]:
         names = {reg.name for reg in variables}
         assert len(variables) == len(names), "Repeating names not allowed"
         return variables
 
-    @pydantic.validator("state_preparation_params")
+    @pydantic.field_validator("state_preparation_params")
+    @classmethod
     def _validate_state_preparation(
-        cls, state_preparation_params: GroverStatePreparation, values: Dict[str, Any]
+        cls, state_preparation_params: GroverStatePreparation, info: ValidationInfo
     ) -> GroverStatePreparation:
-        variables = values.get("variables", list())
+        variables = info.data.get("variables", list())
         sp_inputs = state_preparation_params.inputs_full(strict_zero_ios=False)
         sp_outputs = state_preparation_params.outputs
         if len(sp_inputs) == 1 and len(sp_outputs) == 1:
@@ -82,5 +89,5 @@ class GroverDiffuser(FunctionParams):
         return state_preparation_params
 
     @staticmethod
-    def _names_and_sizes(transputs: ArithmeticIODict) -> Set[Tuple[str, int]]:
+    def _names_and_sizes(transputs: ArithmeticIODict) -> set[tuple[str, int]]:
         return {(name, reg.size) for name, reg in transputs.items()}

classiq/interface/generator/grover_operator.py

@@ -1,7 +1,9 @@
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
 import pydantic
+from pydantic_core.core_schema import ValidationInfo
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.function_params import (
     FunctionParams,
     FunctionParamsDiscriminator,
@@ -18,8 +20,6 @@ from classiq.interface.generator.oracles.oracle_function_param_list import (
 from classiq.interface.generator.range_types import NonNegativeFloatRange
 from classiq.interface.generator.state_preparation import Metrics, StatePreparation
 
-from classiq.exceptions import ClassiqValueError
-
 _DEFAULT_ORACLE_DISCRIMINATOR: FunctionParamsDiscriminator = (
     ArithmeticOracle.discriminator()
 )
@@ -27,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
@@ -74,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

@@ -4,12 +4,11 @@ import pydantic
 
 from classiq.interface.chemistry import operator
 from classiq.interface.chemistry.operator import PauliOperator
+from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.hamiltonian_evolution.hamiltonian_evolution import (
     HamiltonianEvolution,
 )
 
-from classiq._internals.enum_utils import StrEnum
-
 
 class ExponentiationOptimization(StrEnum):
     MINIMIZE_DEPTH = "MINIMIZE_DEPTH"
@@ -24,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):
@@ -46,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)