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

classiq/{quantum_register.py → interface/generator/model/quantum_register.py}

@@ -1,16 +1,15 @@
 import itertools
 import sys
+from collections.abc import Iterator
+from types import GenericAlias as TypesGenericAlias
 from typing import (  # type: ignore[attr-defined]
     Any,
-    Dict,
-    Iterator,
-    List,
     Optional,
-    Type,
     Union,
     _GenericAlias,
 )
 
+from classiq.interface.exceptions import ClassiqQRegError
 from classiq.interface.generator.arith.register_user_input import (
     RegisterArithmeticInfo,
     RegisterUserInput,
@@ -18,11 +17,6 @@ from classiq.interface.generator.arith.register_user_input import (
 from classiq.interface.generator.function_params import ArithmeticIODict, IOName
 from classiq.interface.generator.register_role import RegisterRole
 
-from classiq.exceptions import ClassiqQRegError
-
-if sys.version_info >= (3, 9):
-    from types import GenericAlias as TypesGenericAlias
-
 
 # This class is used for QReg, to support type-hint initialization
 #   Due to the `size` property of QReg
@@ -81,14 +75,17 @@ class QReg:
         """Initializes a new QReg with the specified number of qubits.
 
         Args:
-            size (int): The number of qubits in the QReg.
+            size: The number of qubits in the QReg.
         """
         if size <= 0:
             raise ClassiqQRegError(f"Cannot create {size} new qubits")
         self._qubits = [Qubit() for _ in range(size)]
 
+    def __hash__(self) -> int:
+        return super.__hash__(self)
+
     @classmethod
-    def _from_qubits(cls, qubits: List[Qubit]) -> "QReg":
+    def _from_qubits(cls, qubits: list[Qubit]) -> "QReg":
         if (
             not isinstance(qubits, list)
             or not all(isinstance(qubit, Qubit) for qubit in qubits)
@@ -139,7 +136,7 @@ class QReg:
         return len(self._qubits)
 
     @property
-    def qubits(self) -> List[Qubit]:
+    def qubits(self) -> list[Qubit]:
         return self._qubits
 
     def __class_getitem__(cls, params: Any) -> QRegGenericAlias:
@@ -229,7 +226,7 @@ _PROP_TO_QREG_TYPE = {
 }
 
 
-def _get_qreg_type_from_arithmetic_info(info: RegisterArithmeticInfo) -> Type["QReg"]:
+def _get_qreg_type_from_arithmetic_info(info: RegisterArithmeticInfo) -> type["QReg"]:
     return _PROP_TO_QREG_TYPE[(info.is_signed, info.is_frac)]
 
 
@@ -245,7 +242,7 @@ def _get_qreg_generic_alias_from_arithmetic_info(
 
 def get_type_and_size_dict(
     arithmetic_info_dict: ArithmeticIODict,
-) -> Dict[IOName, QRegGenericAlias]:
+) -> dict[IOName, QRegGenericAlias]:
     return {
         io_name: _get_qreg_generic_alias_from_arithmetic_info(info)
         for io_name, info in arithmetic_info_dict.items()
@@ -253,11 +250,11 @@ def get_type_and_size_dict(
 
 
 __all__ = [
+    "AuxQReg",
     "QReg",
-    "QSInt",
-    "QUInt",
     "QSFixed",
+    "QSInt",
     "QUFixed",
+    "QUInt",
     "ZeroQReg",
-    "AuxQReg",
 ]

classiq/interface/generator/oracles/arithmetic_oracle.py

@@ -1,9 +1,9 @@
 import ast
 import re
-from typing import Dict
 
 import numexpr  # type: ignore[import]
 
+from classiq.interface.exceptions import ClassiqArithmeticError, ClassiqValueError
 from classiq.interface.generator.arith import number_utils
 from classiq.interface.generator.arith.arithmetic import Arithmetic
 from classiq.interface.generator.arith.arithmetic_expression_abc import (
@@ -17,8 +17,6 @@ from classiq.interface.generator.oracles.oracle_abc import (
     VariableTypedResultMap,
 )
 
-from classiq.exceptions import ClassiqArithmeticError, ClassiqValueError
-
 
 class ArithmeticOracle(OracleABC[float], ArithmeticExpressionABC):
     @staticmethod
@@ -62,7 +60,7 @@ class ArithmeticOracle(OracleABC[float], ArithmeticExpressionABC):
 
     @staticmethod
     def _simplify_negations_of_boolean_variables(
-        expression: str, input_definitions: Dict[str, RegisterArithmeticInfo]
+        expression: str, input_definitions: dict[str, RegisterArithmeticInfo]
     ) -> str:
         for var_name in input_definitions:
             if getattr(input_definitions[var_name], "size", 0) == 1:

classiq/interface/generator/oracles/custom_oracle.py

@@ -1,7 +1,8 @@
-from typing import Any, Dict
+from typing import Any
 
 import pydantic
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.function_params import parse_function_params_values
 from classiq.interface.generator.oracles.oracle_abc import (
     ArithmeticIODict,
@@ -11,8 +12,6 @@ from classiq.interface.generator.oracles.oracle_abc import (
 )
 from classiq.interface.generator.user_defined_function_params import CustomFunction
 
-from classiq.exceptions import ClassiqValueError
-
 QubitState = str
 
 
@@ -23,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/oracles/oracle_abc.py

@@ -1,19 +1,19 @@
 import abc
-from typing import Dict, Generic, List, Optional, Sequence, TypeVar
+from collections.abc import Sequence
+from typing import Generic, Optional, TypeVar
 
 import numpy as np
 
+from classiq.interface.exceptions import ClassiqOracleError
 from classiq.interface.executor.result import State
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.function_params import ArithmeticIODict, FunctionParams
 from classiq.interface.generator.generated_circuit_data import IOQubitMapping
 
-from classiq.exceptions import ClassiqOracleError
-
 ProblemResultType = TypeVar("ProblemResultType")
 
-VariableBinResultMap = Dict[str, State]
-VariableTypedResultMap = Dict[str, ProblemResultType]
+VariableBinResultMap = dict[str, State]
+VariableTypedResultMap = dict[str, ProblemResultType]
 
 
 class OracleABC(abc.ABC, FunctionParams, Generic[ProblemResultType]):
@@ -59,7 +59,7 @@ class OracleABC(abc.ABC, FunctionParams, Generic[ProblemResultType]):
     ) -> bool:
         pass
 
-    def variables(self) -> List[RegisterUserInput]:
+    def variables(self) -> list[RegisterUserInput]:
         return [
             RegisterUserInput.from_arithmetic_info(info=info, name=name)
             for name, info in self._inputs.items()
@@ -72,5 +72,5 @@ class OracleABC(abc.ABC, FunctionParams, Generic[ProblemResultType]):
             )
 
 
-def _reverse_endianness(indices: Sequence[int], state_length: int) -> List[int]:
+def _reverse_endianness(indices: Sequence[int], state_length: int) -> list[int]:
     return [state_length - 1 - index for index in indices]

classiq/interface/generator/partitioned_register.py

@@ -1,11 +1,11 @@
 import itertools
+from collections.abc import Iterator
 from dataclasses import dataclass
-from typing import Iterator, List, Optional, Tuple
+from typing import Optional
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.slice_parsing_utils import parse_io_slicing
 
-from classiq.exceptions import ClassiqValueError
-
 
 @dataclass(frozen=True)
 class PartitionedRegister:
@@ -13,7 +13,7 @@ class PartitionedRegister:
 
     # There are up to num_qubits qubits within the partitions, with unique values from 0 to num_qubits-1
     num_qubits: int
-    partitions: Tuple[Tuple[int, ...], ...]
+    partitions: tuple[tuple[int, ...], ...]
 
     def __post_init__(self) -> None:
         if not self.partitions:
@@ -48,7 +48,7 @@ class PartitionedRegister:
         return RegisterPartition(self, _index=None)
 
     @property
-    def _leftover_qubits(self) -> Tuple[int, ...]:
+    def _leftover_qubits(self) -> tuple[int, ...]:
         total_qubits = set(itertools.chain.from_iterable(self.partitions))
         return tuple(
             qubit for qubit in range(self.num_qubits) if qubit not in total_qubits
@@ -60,7 +60,7 @@ class PartitionedRegister:
 
     def all_register_partitions(
         self, include_leftover_partition: bool = False
-    ) -> List["RegisterPartition"]:
+    ) -> list["RegisterPartition"]:
         all_partitions = [self.get_partition(i) for i in range(len(self.partitions))]
         if include_leftover_partition:
             all_partitions.append(self.leftover_partition)
@@ -83,7 +83,7 @@ class RegisterPartition:
             raise ClassiqValueError(message)
 
     @property
-    def qubits(self) -> Tuple[int, ...]:
+    def qubits(self) -> tuple[int, ...]:
         if self._index is None:
             return self.partitioned_register._leftover_qubits
         return self.partitioned_register.partitions[self._index]

classiq/interface/generator/piecewise_linear_amplitude_loading.py

@@ -1,16 +1,18 @@
 import math
-from typing import Any, Dict, Generic, List, Sequence, Tuple, TypeVar
+from collections.abc import Sequence
+from typing import Any, Generic, 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
 from classiq.interface.generator.function_params import FunctionParams
 from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
 
-from classiq.exceptions import ClassiqError
-
 STATE_NAME: str = "state"
 TARGET_NAME: str = "target"
 _REL_TOLERANCE: float = 0.01
@@ -19,25 +21,24 @@ 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
 
-    def image_bounds(self, domain_bounds: Tuple[float, float]) -> Tuple[float, float]:
+    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 = {
@@ -50,8 +51,8 @@ class PiecewiseLinearAmplitudeLoadingABC(
     def _max_index(self) -> int:
         return 2**self.num_qubits - 1
 
-    def _get_image_bounds(self) -> Tuple[float, float]:
-        piece_bounds: Sequence[Tuple[float, float]] = [
+    def _get_image_bounds(self) -> tuple[float, float]:
+        piece_bounds: Sequence[tuple[float, float]] = [
             affine_map.image_bounds((self.breakpoints[idx], self.breakpoints[idx + 1]))
             for idx, affine_map in enumerate(self.affine_maps)
         ]
@@ -59,19 +60,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"
@@ -81,28 +98,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()
@@ -111,11 +127,11 @@ class PiecewiseLinearAmplitudeLoading(PiecewiseLinearAmplitudeLoadingABC[float])
 
         a, b = self.breakpoints[0], self.breakpoints[-1]
 
-        normalized_breakpoints: List[int] = [
+        normalized_breakpoints: list[int] = [
             round(self._max_index * (point - a) / (b - a)) for point in self.breakpoints
         ]
 
-        normalized_affine_maps: List[AffineMap] = list()
+        normalized_affine_maps: list[AffineMap] = list()
         for affine_map in self.affine_maps:
             normalized_slope = (
                 2 * affine_map.slope * self.rescaling_factor * (b - a)

classiq/interface/generator/preferences/optimization.py

@@ -1,11 +1,10 @@
 from pydantic import BaseModel
 
+from classiq.interface.enum_utils import StrEnum
 from classiq.interface.helpers.custom_pydantic_types import (
     PydanticNonOneProbabilityFloat,
 )
 
-from classiq._internals.enum_utils import StrEnum
-
 
 # it seems to be ambiguous in this class. it is Identical to the Metrics, up to  the
 # attribute RANDOM, However RANDOM isn't really used or treated in any part of the code.

classiq/interface/generator/qpe.py

@@ -1,7 +1,11 @@
-from typing import Any, Dict, Optional, Tuple
+from typing import Any, Optional
 
 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
 from classiq.interface.generator.function_param_list_without_self_reference import (
     function_param_library_without_self_reference,
@@ -17,8 +21,6 @@ from classiq.interface.generator.hamiltonian_evolution.exponentiation import (
 )
 from classiq.interface.generator.user_defined_function_params import CustomFunction
 
-from classiq.exceptions import ClassiqMismatchIOsError, ClassiqValueError
-
 PHASE_ESTIMATION_DEFAULT_OUTPUT_NAME = "PHASE_ESTIMATION"
 CUSTOM_FUNCTIONS_IO_MISMATCH_ERROR = (
     "Custom function provided to the QPE has different input and output names."
@@ -37,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):
@@ -52,21 +52,17 @@ class ExponentiationSpecification(pydantic.BaseModel):
         default=None,
         description="The scaling of the exponentiation functions.",
     )
-    max_depths: Optional[Tuple[pydantic.NonNegativeInt, ...]] = pydantic.Field(
+    max_depths: Optional[tuple[pydantic.NonNegativeInt, ...]] = pydantic.Field(
         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):
@@ -105,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):
@@ -136,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

@@ -1,8 +1,11 @@
-from typing import List, Literal, Optional, Union
+from typing import 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
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.function_params import (
     DEFAULT_INPUT_NAME,
@@ -13,9 +16,6 @@ from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
 
-from classiq._internals.enum_utils import StrEnum
-from classiq.exceptions import ClassiqQSVMError, ClassiqValueError
-
 VALID_PAULI_LETTERS = ("I", "X", "Y", "Z")
 
 
@@ -29,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):
@@ -39,12 +37,13 @@ class QSVMFeatureMapPauli(QSVMFeatureMapDimensional):
     reps: int = 2
     entanglement: QSVMFeatureMapEntanglement = QSVMFeatureMapEntanglement.LINEAR
     alpha: float = 2.0
-    paulis: List[str] = ["Z", "ZZ"]
+    paulis: list[str] = ["Z", "ZZ"]
     parameter_prefix: str = "x"
     name: str = "PauliFeatureMap"
 
-    @pydantic.validator("paulis", pre=True)
-    def set_paulis(cls, paulis: List[str]) -> List[str]:
+    @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:
             if not all(map(VALID_PAULI_LETTERS.__contains__, s.upper())):