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

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:
-            raise ValueError("At least one specification must be provided.")
-        return values
+    @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 self
 
 
 class PhaseEstimation(FunctionParams):
@@ -105,52 +101,69 @@ 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):
                 raise ClassiqMismatchIOsError(CUSTOM_FUNCTIONS_IO_MISMATCH_ERROR)
-            raise ValueError(
+            raise ClassiqValueError(
                 f"Phase estimation of {unitary_params.discriminator()} is currently not supported."
             )
         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 ValueError(
+            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"):
-            raise ValueError("Length of max_depths must match the provided size.")
+        ) != validation_info.data.get("size"):
+            raise ClassiqValueError(
+                "Length of max_depths must match the provided size."
+            )
         return exponentiation_specification

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,
@@ -12,10 +15,6 @@ from classiq.interface.generator.function_params import (
 from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
-from classiq.interface.helpers.pydantic_model_helpers import get_discriminator_field
-
-from classiq._internals.enum_utils import StrEnum
-from classiq.exceptions import ClassiqQSVMError
 
 VALID_PAULI_LETTERS = ("I", "X", "Y", "Z")
 
@@ -30,36 +29,33 @@ class QSVMFeatureMapEntanglement(StrEnum):
 
 class QSVMFeatureMapDimensional(HashablePydanticBaseModel):
     feature_dimension: Optional[int] = None
-
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
 
 class QSVMFeatureMapPauli(QSVMFeatureMapDimensional):
-    map_type: Literal["pauli_feature_map"] = get_discriminator_field(
-        "pauli_feature_map"
-    )
+    map_type: Literal["pauli_feature_map"] = pydantic.Field(default="pauli_feature_map")
     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())):
-                raise ValueError(
+                raise ClassiqValueError(
                     f"Invalid pauli string given: {s!r}. Expecting a combination of {VALID_PAULI_LETTERS}"
                 )
         return list(map(str.upper, paulis))
 
 
 class QSVMFeatureMapBlochSphere(QSVMFeatureMapDimensional):
-    map_type: Literal["bloch_sphere_feature_map"] = get_discriminator_field(
-        "bloch_sphere_feature_map"
+    map_type: Literal["bloch_sphere_feature_map"] = pydantic.Field(
+        default="bloch_sphere_feature_map"
     )