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

classiq/interface/chemistry/molecule.py

@@ -1,6 +1,7 @@
 from typing import List, Literal, Union
 
 import pydantic
+from pydantic import ConfigDict
 
 from classiq.interface.chemistry.elements import ELEMENTS
 from classiq.interface.exceptions import ClassiqValueError
@@ -20,7 +21,7 @@ class Atom(HashablePydanticBaseModel):
 class Molecule(HashablePydanticBaseModel):
     atoms: List[Atom] = pydantic.Field(
         description="A list of atoms each containing the atoms symbol and  its (x,y,z) location",
-        min_items=1,
+        min_length=1,
     )
     spin: pydantic.NonNegativeInt = pydantic.Field(
         default=1, description="spin of the molecule"
@@ -33,12 +34,17 @@ class Molecule(HashablePydanticBaseModel):
     def atoms_type(self) -> List[AtomType]:
         return [(atom.symbol, [atom.x, atom.y, atom.z]) for atom in self.atoms]
 
-    @pydantic.validator("atoms", each_item=True, pre=True)
-    def _validate_atoms(cls, atom: Union[AtomType, Atom]) -> Atom:
+    @classmethod
+    def _validate_atom(cls, atom: Union[AtomType, Atom]) -> Atom:
         if isinstance(atom, (list, tuple)):
             return cls._validate_old_atoms_type(atom)
         return atom
 
+    @pydantic.field_validator("atoms", mode="before")
+    @classmethod
+    def _validate_atoms(cls, atoms: List[Union[AtomType, Atom]]) -> List[Atom]:
+        return [cls._validate_atom(atom) for atom in atoms]
+
     @staticmethod
     def _validate_old_atoms_type(atom: AtomType) -> Atom:
         if len(atom) != 2:
@@ -62,5 +68,4 @@ class Molecule(HashablePydanticBaseModel):
 
         return Atom(symbol=symbol, x=coordinate[0], y=coordinate[1], z=coordinate[2])
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)

classiq/interface/chemistry/operator.py

@@ -5,7 +5,6 @@ from typing import (
     Dict,
     List,
     Optional,
-    Tuple,
     Union,
     cast,
 )
@@ -14,6 +13,7 @@ import numpy as np
 import pydantic
 import sympy
 from more_itertools import all_equal
+from pydantic import ConfigDict
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.function_params import validate_expression_str
@@ -42,8 +42,8 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
     pauli_list: PydanticPauliList = pydantic.Field(
         description="A list of tuples each containing a pauli string comprised of I,X,Y,Z characters and a complex coefficient; for example [('IZ', 0.1), ('XY', 0.2)].",
     )
-    is_hermitian: bool = pydantic.Field(default=False)
     has_complex_coefficients: bool = pydantic.Field(default=True)
+    is_hermitian: bool = pydantic.Field(default=False)
 
     def show(self) -> str:
         if self.is_hermitian:
@@ -55,16 +55,19 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
             f"+({summand[1]:+.3f}) * {summand[0]}" for summand in self.pauli_list
         )
 
-    @pydantic.validator("pauli_list", each_item=True, pre=True)
+    @pydantic.field_validator("pauli_list", mode="before")
+    @classmethod
     def _validate_pauli_monomials(
-        cls, monomial: Tuple[PydanticPauliMonomialStr, ParameterComplexType]
-    ) -> Tuple[PydanticPauliMonomialStr, ParameterComplexType]:
-        _PauliMonomialLengthValidator(  # type: ignore[call-arg]
-            monomial=monomial
-        )  # Validate the length of the monomial.
-        coeff = cls._validate_monomial_coefficient(monomial[1])
-        parsed_monomial = _PauliMonomialParser(string=monomial[0], coeff=coeff)  # type: ignore[call-arg]
-        return (parsed_monomial.string, parsed_monomial.coeff)
+        cls, pauli_list: PydanticPauliList
+    ) -> PydanticPauliList:
+        validated_pauli_list = []
+        for monomial in pauli_list:
+            # Validate the length
+            _PauliMonomialLengthValidator(monomial=monomial)  # type: ignore[call-arg]
+            coeff = cls._validate_monomial_coefficient(monomial[1])
+            parsed_monomial = _PauliMonomialParser(string=monomial[0], coeff=coeff)
+            validated_pauli_list.append((parsed_monomial.string, parsed_monomial.coeff))
+        return validated_pauli_list
 
     @staticmethod
     def _validate_monomial_coefficient(
@@ -76,16 +79,38 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
             coeff = str(coeff)
         return coeff
 
-    @pydantic.validator("pauli_list")
+    @pydantic.field_validator("pauli_list", mode="after")
+    @classmethod
     def _validate_pauli_list(cls, pauli_list: PydanticPauliList) -> PydanticPauliList:
         if not all_equal(len(summand[0]) for summand in pauli_list):
             raise ClassiqValueError("Pauli strings have incompatible lengths.")
         return pauli_list
 
-    @pydantic.root_validator
+    @staticmethod
+    def check_if_hermitian(pauli_list: PydanticPauliList) -> bool:
+        if all(isinstance(summand[1], (float, int, complex)) for summand in pauli_list):
+            if all(np.isclose(summand[1].imag, 0) for summand in pauli_list):  # type: ignore[union-attr]
+                return True
+
+            for pauli_string, coeff in pauli_list:
+                reverse_string = pauli_string[::-1]
+                reverse_found = False
+                for other_string, other_coeff in pauli_list:
+                    if other_string == reverse_string and np.isclose(
+                        coeff, other_coeff.conjugate()  # type: ignore[union-attr]
+                    ):
+                        reverse_found = True
+                        break
+                if not reverse_found:
+                    return False
+            return True
+        return False
+
+    @pydantic.model_validator(mode="before")
+    @classmethod
     def _validate_hermitianity(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         pauli_list = values.get("pauli_list", [])
-        if all(isinstance(summand[1], complex) for summand in pauli_list):
+        if PauliOperator.check_if_hermitian(pauli_list):
             values["is_hermitian"] = all(
                 np.isclose(complex(summand[1]).real, summand[1])
                 for summand in pauli_list
@@ -93,7 +118,7 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
         if values.get("is_hermitian", False):
             values["has_complex_coefficients"] = False
             values["pauli_list"] = [
-                (summand[0], complex(summand[1].real)) for summand in pauli_list
+                (summand[0], complex(summand[1]).real) for summand in pauli_list
             ]
         else:
             values["has_complex_coefficients"] = not all(
@@ -161,7 +186,7 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
             (self._extend_pauli_string(pauli_string, num_extra_qubits), coeff)
             for (pauli_string, coeff) in self.pauli_list
         ]
-        return self.copy(update={"pauli_list": new_pauli_list}, deep=True)
+        return self.model_copy(update={"pauli_list": new_pauli_list}, deep=True)
 
     @staticmethod
     def _reorder_pauli_string(
@@ -211,7 +236,7 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
             (cls._reorder_pauli_string(pauli_string, order, new_num_qubits), coeff)
             for pauli_string, coeff in operator.pauli_list
         ]
-        return cls(pauli_list=new_pauli_list)
+        return cls(pauli_list=new_pauli_list, is_hermitian=operator.is_hermitian)
 
     @classmethod
     def from_unzipped_lists(
@@ -234,8 +259,7 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
             ]
         )
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
 
 class PauliOperatorV1(HashablePydanticBaseModel):
@@ -259,16 +283,19 @@ class PauliOperatorV1(HashablePydanticBaseModel):
             f"+({summand[1]:+.3f}) * {summand[0]}" for summand in self.pauli_list
         )
 
-    @pydantic.validator("pauli_list", each_item=True, pre=True)
+    @pydantic.field_validator("pauli_list", mode="before")
+    @classmethod
     def _validate_pauli_monomials(
-        cls, monomial: Tuple[PydanticPauliMonomialStr, ParameterComplexType]
-    ) -> Tuple[PydanticPauliMonomialStr, ParameterComplexType]:
-        _PauliMonomialLengthValidator(  # type: ignore[call-arg]
-            monomial=monomial
-        )  # Validate the length of the monomial.
-        coeff = cls._validate_monomial_coefficient(monomial[1])
-        parsed_monomial = _PauliMonomialParser(string=monomial[0], coeff=coeff)  # type: ignore[call-arg]
-        return (parsed_monomial.string, parsed_monomial.coeff)
+        cls, pauli_list: PydanticPauliList
+    ) -> PydanticPauliList:
+        validated_pauli_list = []
+        for monomial in pauli_list:
+            # Validate the length
+            _PauliMonomialLengthValidator(monomial=monomial)  # type: ignore[call-arg]
+            coeff = cls._validate_monomial_coefficient(monomial[1])
+            parsed_monomial = _PauliMonomialParser(string=monomial[0], coeff=coeff)
+            validated_pauli_list.append((parsed_monomial.string, parsed_monomial.coeff))
+        return validated_pauli_list
 
     @staticmethod
     def _validate_monomial_coefficient(
@@ -280,32 +307,34 @@ class PauliOperatorV1(HashablePydanticBaseModel):
             coeff = str(coeff)
         return coeff
 
-    @pydantic.validator("pauli_list")
+    @pydantic.field_validator("pauli_list", mode="after")
+    @classmethod
     def _validate_pauli_list(cls, pauli_list: PydanticPauliList) -> PydanticPauliList:
         if not all_equal(len(summand[0]) for summand in pauli_list):
             raise ClassiqValueError("Pauli strings have incompatible lengths.")
         return pauli_list
 
-    @pydantic.root_validator
-    def _validate_hermitianity(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        pauli_list = values.get("pauli_list", [])
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _validate_hermitianity(cls, v: Dict[str, Any]) -> Dict[str, Any]:
+        pauli_list = cast(PydanticPauliList, v.get("pauli_list"))
         if all(isinstance(summand[1], complex) for summand in pauli_list):
-            values["is_hermitian"] = all(
+            v["is_hermitian"] = all(
                 np.isclose(complex(summand[1]).real, summand[1])
                 for summand in pauli_list
             )
-        if values.get("is_hermitian", False):
-            values["has_complex_coefficients"] = False
-            values["pauli_list"] = [
-                (summand[0], complex(summand[1].real)) for summand in pauli_list
+        if v["is_hermitian"]:
+            v["has_complex_coefficients"] = False
+            v["pauli_list"] = [
+                (summand[0], complex(summand[1]).real) for summand in pauli_list
             ]
         else:
-            values["has_complex_coefficients"] = not all(
+            v["has_complex_coefficients"] = not all(
                 np.isclose(complex(summand[1]).real, summand[1])
                 for summand in pauli_list
                 if isinstance(summand[1], complex)
             )
-        return values
+        return v
 
     def __mul__(self, coefficient: complex) -> "PauliOperatorV1":
         multiplied_ising = [
@@ -361,7 +390,7 @@ class PauliOperatorV1(HashablePydanticBaseModel):
             (self._extend_pauli_string(pauli_string, num_extra_qubits), coeff)
             for (pauli_string, coeff) in self.pauli_list
         ]
-        return self.copy(update={"pauli_list": new_pauli_list}, deep=True)
+        return self.model_copy(update={"pauli_list": new_pauli_list}, deep=True)
 
     @staticmethod
     def _reorder_pauli_string(
@@ -434,8 +463,7 @@ class PauliOperatorV1(HashablePydanticBaseModel):
             ]
         )
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
 
 # This class validates the length of a monomial.
@@ -444,8 +472,7 @@ class _PauliMonomialLengthValidator:
     monomial: PydanticPauliMonomial
 
 
-@pydantic.dataclasses.dataclass
-class _PauliMonomialParser:
+class _PauliMonomialParser(pydantic.BaseModel):
     string: PydanticPauliMonomialStr
     coeff: PydanticParameterComplexType
 

classiq/interface/combinatorial_optimization/mht_qaoa_input.py

@@ -53,7 +53,8 @@ class MhtQaoaInput(BaseModel):
     def is_valid_cost(self, cost: float) -> bool:
         return True
 
-    @pydantic.validator("plot_list")
+    @pydantic.field_validator("plot_list")
+    @classmethod
     def round_plot_list_times_and_validate(
         cls, plot_list: List[PlotData]
     ) -> List[PlotData]:

classiq/interface/debug_info/debug_info.py

@@ -15,8 +15,7 @@ ParameterValue = Union[float, int, str, None]
 class FunctionDebugInfo(BaseModel):
     name: str
     # Parameters describe classical parameters passed to function
-    # ParameterValue appears in type only for backwards compatibility
-    parameters: Dict[str, str] = Field(type=Dict[str, ParameterValue])
+    parameters: Dict[str, str]
     level: OperationLevel
     is_allocate_or_free: bool = Field(default=False)
     is_inverse: bool = Field(default=False)
@@ -54,8 +53,8 @@ class DebugInfoCollection(BaseModel):
     # Pydantic only started supporting UUID as keys in Pydantic V2
     # See https://github.com/pydantic/pydantic/issues/2096#issuecomment-814860206
     # For now, we use strings as keys in the raw data and use UUID in the wrapper logic
-    data: Dict[str, FunctionDebugInfo] = Field(default_factory=dict)
-    blackbox_data: Dict[str, FunctionDebugInfoInterface] = Field(default_factory=dict)
+    data: Dict[str, FunctionDebugInfo] = Field(default={})
+    blackbox_data: Dict[str, FunctionDebugInfoInterface] = Field(default={})
 
     def __setitem__(self, key: UUID, value: FunctionDebugInfo) -> None:
         self.data[str(key)] = value

classiq/interface/execution/iqcc.py

@@ -0,0 +1,21 @@
+from typing import Optional
+
+from classiq.interface.helpers.versioned_model import VersionedModel
+
+
+class IQCCInitAuthData(VersionedModel):
+    auth_scope_id: str
+    auth_method_id: str
+
+
+class IQCCInitAuthResponse(VersionedModel):
+    auth_url: str
+    token_id: str
+
+
+class IQCCProbeAuthData(IQCCInitAuthData):
+    token_id: str
+
+
+class IQCCProbeAuthResponse(VersionedModel):
+    auth_token: Optional[str]

classiq/interface/execution/jobs.py

@@ -1,28 +1,28 @@
 from datetime import datetime
 from typing import List, Optional
 
-from pydantic import BaseModel, Extra
+from pydantic import BaseModel
 
 from classiq.interface.jobs import JobStatus
 
 
-class ExecutionJobDetailsV1(BaseModel, extra=Extra.ignore):
+class ExecutionJobDetailsV1(BaseModel, extra="ignore"):
     id: str
 
-    name: Optional[str]
+    name: Optional[str] = None
     start_time: datetime
-    end_time: Optional[datetime]
+    end_time: Optional[datetime] = None
 
-    provider: Optional[str]
-    backend_name: Optional[str]
+    provider: Optional[str] = None
+    backend_name: Optional[str] = None
 
     status: JobStatus
 
-    num_shots: Optional[int]
-    program_id: Optional[str]
+    num_shots: Optional[int] = None
+    program_id: Optional[str] = None
 
-    error: Optional[str]
+    error: Optional[str] = None
 
 
-class ExecutionJobsQueryResultsV1(BaseModel, extra=Extra.ignore):
+class ExecutionJobsQueryResultsV1(BaseModel, extra="ignore"):
     results: List[ExecutionJobDetailsV1]

classiq/interface/executor/aws_execution_cost.py

@@ -1,11 +1,12 @@
+import datetime
 from datetime import date
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
 import pydantic
-from pydantic import validator
+from pydantic import BaseModel, ConfigDict, Field
+from pydantic_core.core_schema import ValidationInfo
 
 from classiq.interface.enum_utils import StrEnum
-from classiq.interface.exceptions import ClassiqValueError
 
 
 class Granularity(StrEnum):
@@ -19,30 +20,44 @@ class CostScope(StrEnum):
     organization = "organization"
 
 
-class ExecutionCostForTimePeriod(pydantic.BaseModel):
-    start: date = pydantic.Field(
-        description="The beginning of the time period for tasks usage and cost ("
-        "inclusive).",
+class ExecutionCostForTimePeriod(BaseModel):
+    start: date = Field(
+        description="The beginning of the time period for tasks usage and cost (inclusive)."
     )
-    end: date = pydantic.Field(
-        description="The end of the time period for tasks usage and cost (exclusive).",
+    end: date = Field(
+        description="The end of the time period for tasks usage and cost (exclusive)."
     )
-    granularity: Granularity = pydantic.Field(
+    granularity: Granularity = Field(
         description="Either MONTHLY or DAILY, or HOURLY.", default=Granularity.daily
     )
-    cost_scope: CostScope = pydantic.Field(
+    cost_scope: CostScope = Field(
         description="Either user or organization", default=CostScope.user
     )
 
-    class Config:
-        json_encoders = {date: lambda v: v.strftime("%Y-%m-%d")}
-
-    @validator("end")
-    def date_order(cls, v: date, values: Dict[str, Any], **kwargs: Any) -> date:
-        if "start" in values and v <= values["start"]:
-            raise ClassiqValueError('"end" date should be after "start" date')
+    @pydantic.field_validator("start", mode="before")
+    @classmethod
+    def validate_start_date(cls, start_date: Union[datetime.datetime, date]) -> date:
+        if isinstance(start_date, datetime.datetime):
+            return start_date.date()
+        return start_date
+
+    @pydantic.field_validator("end", mode="before")
+    @classmethod
+    def validate_date_and_date_order(
+        cls, v: Union[date, datetime.datetime], info: ValidationInfo
+    ) -> date:
+        if isinstance(v, datetime.datetime):
+            v = v.date()
+        if "start" in info.data and v <= info.data["start"]:
+            raise ValueError('"end" date should be after "start" date')
         return v
 
+    def dict(self, **kwargs: Any) -> Dict[str, Any]:
+        data = super().model_dump(**kwargs)
+        data["start"] = self.start.strftime("%Y-%m-%d")
+        data["end"] = self.end.strftime("%Y-%m-%d")
+        return data
+
 
 """The following models describe the aws response model and based on this schema:
 https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/ce.html#CostExplorer.Client.get_cost_and_usage"""
@@ -65,8 +80,10 @@ class Total(pydantic.BaseModel):
 class ExecutedTaskForPeriodItem(pydantic.BaseModel):
     TimePeriod: TimePeriod
     Total: Total
-    Groups: Optional[List]
-    Estimated: Optional[bool]
+    Groups: Optional[List] = None
+    Estimated: Optional[bool] = None
+
+    model_config = ConfigDict(extra="forbid")
 
 
 class ExecutionCostForTimePeriodResponse(pydantic.BaseModel):

classiq/interface/executor/execution_preferences.py

@@ -59,8 +59,7 @@ class ExecutionPreferences(pydantic.BaseModel):
         title="Transpilation Option",
     )
     job_name: Optional[str] = pydantic.Field(
-        min_length=1,
-        description="The job name",
+        min_length=1, description="The job name", default=None
     )
 
 

classiq/interface/executor/execution_request.py

@@ -57,9 +57,9 @@ class ExecutionJobDetails(VersionedModel):
     status: JobStatus
 
     num_shots: Optional[int]
-    program_id: Optional[str]
+    program_id: Optional[str] = Field(default=None)
 
-    error: Optional[str]
+    error: Optional[str] = Field(default=None)
 
 
 class ExecutionJobsQueryResults(VersionedModel):

classiq/interface/executor/execution_result.py

@@ -1,6 +1,6 @@
 from typing import Any, List, Literal, Union
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
 from typing_extensions import Annotated, TypeAlias
 
 from classiq.interface.enum_utils import StrEnum
@@ -85,7 +85,7 @@ class TaggedIQAEResult(BaseModel):
 class TaggedUnstructured(BaseModel):
     value_type: Literal[SavedResultValueType.Unstructured]
     name: str
-    value: Any
+    value: Any = None
 
 
 SavedResult = Annotated[
@@ -109,3 +109,5 @@ ResultsCollection: TypeAlias = List[SavedResult]
 
 class ExecuteGeneratedCircuitResults(VersionedModel):
     results: ResultsCollection
+
+    model_config = ConfigDict(extra="forbid")

classiq/interface/executor/iqae_result.py

@@ -14,6 +14,6 @@ class IQAEIterationData(BaseModel):
 
 class IQAEResult(VersionedModel, QmodPyObject):
     estimation: float
-    confidence_interval: List[float] = Field(min_items=2, max_items=2)
+    confidence_interval: List[float] = Field(min_length=2, max_length=2)
     iterations_data: List[IQAEIterationData]
     warnings: List[str]

classiq/interface/executor/optimizer_preferences.py

@@ -1,7 +1,8 @@
-from typing import Any, Dict, List, Optional
+from typing import List, Optional
 
 import pydantic
 from pydantic import BaseModel
+from pydantic_core.core_schema import ValidationInfo
 
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.exceptions import ClassiqValueError
@@ -53,11 +54,12 @@ class OptimizerPreferences(BaseModel):
         description="If True, the optimizer will not compute the variance of the ansatz.",
     )
 
-    @pydantic.validator("tolerance", pre=True, always=True)
+    @pydantic.field_validator("tolerance", mode="before")
+    @classmethod
     def check_tolerance(
-        cls, tolerance: Optional[pydantic.PositiveFloat], values: Dict[str, Any]
+        cls, tolerance: Optional[pydantic.PositiveFloat], info: ValidationInfo
     ) -> Optional[pydantic.PositiveFloat]:
-        optimizer_type = values.get("type")
+        optimizer_type = info.data.get("type")
         if tolerance is not None and optimizer_type == OptimizerType.SPSA:
             raise ClassiqValueError("No tolerance param for SPSA optimizer")
 
@@ -66,11 +68,12 @@ class OptimizerPreferences(BaseModel):
 
         return tolerance
 
-    @pydantic.validator("step_size", pre=True, always=True)
+    @pydantic.field_validator("step_size", mode="before")
+    @classmethod
     def check_step_size(
-        cls, step_size: Optional[pydantic.PositiveFloat], values: Dict[str, Any]
+        cls, step_size: Optional[pydantic.PositiveFloat], info: ValidationInfo
     ) -> Optional[pydantic.PositiveFloat]:
-        optimizer_type = values.get("name")
+        optimizer_type = info.data.get("name")
         if step_size is not None and optimizer_type not in (
             OptimizerType.L_BFGS_B,
             OptimizerType.ADAM,
@@ -109,11 +112,12 @@ class CombinatorialOptimizer(OptimizerPreferences):
         description="Whether to check if all the solutions satisfy the constraints",
     )
 
-    @pydantic.validator("alpha_cvar", pre=True, always=True)
+    @pydantic.field_validator("alpha_cvar", mode="before")
+    @classmethod
     def check_alpha_cvar(
-        cls, alpha_cvar: Optional[PydanticAlphaParamCVAR], values: Dict[str, Any]
+        cls, alpha_cvar: Optional[PydanticAlphaParamCVAR], info: ValidationInfo
     ) -> Optional[PydanticAlphaParamCVAR]:
-        cost_type = values.get("cost_type")
+        cost_type = info.data.get("cost_type")
         if alpha_cvar is not None and cost_type != CostType.CVAR:
             raise ClassiqValueError("Use CVAR params only for CostType.CVAR.")
 

classiq/interface/executor/quantum_code.py

@@ -4,7 +4,8 @@ from pathlib import Path
 from typing import Any, Dict, Optional, Tuple, Union
 
 import pydantic
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict
+from pydantic_core.core_schema import ValidationInfo
 
 from classiq.interface.backend.ionq.ionq_quantum_program import IonqQuantumCircuit
 from classiq.interface.backend.pydantic_backend import PydanticArgumentNameType
@@ -31,17 +32,18 @@ class QuantumBaseCode(BaseModel):
         ..., description="The textual representation of the program"
     )
 
-    @pydantic.validator("code")
+    @pydantic.field_validator("code")
+    @classmethod
     def load_quantum_program(
-        cls, code: Union[CodeType, IonqQuantumCircuit], values: Dict[str, Any]
+        cls, code: Union[CodeType, IonqQuantumCircuit], values: ValidationInfo
     ) -> CodeType:
-        syntax = values.get("syntax")
+        syntax = values.data.get("syntax")
         if isinstance(code, IonqQuantumCircuit):
             if syntax != QuantumInstructionSet.IONQ:
                 raise ClassiqValueError(
                     f"Invalid code type {type(code)} for syntax: {syntax}"
                 )
-            return code.json()
+            return code.model_dump_json()
 
         return code
 
@@ -56,41 +58,44 @@ class QuantumCode(QuantumBaseCode):
         description="The map of outputs to their qubits in the circuit.",
     )
     registers_initialization: Optional[RegistersInitialization] = pydantic.Field(
-        default_factory=None,
+        default=None,
         description="Initial conditions for the different registers in the circuit.",
     )
     synthesis_execution_data: Optional[ExecutionData] = pydantic.Field(default=None)
     synthesis_execution_arguments: Arguments = pydantic.Field(default_factory=dict)
+    model_config = ConfigDict(validate_assignment=True)
 
-    class Config:
-        validate_assignment = True
-
-    @pydantic.validator("arguments")
+    @pydantic.field_validator("arguments", mode="before")
+    @classmethod
     def validate_arguments(
-        cls, arguments: MultipleArguments, values: Dict[str, Any]
+        cls, arguments: MultipleArguments, info: ValidationInfo
     ) -> MultipleArguments:
-        if arguments and values.get("syntax") not in (
+        if arguments and info.data.get("syntax") not in (
             QuantumInstructionSet.QSHARP,
             QuantumInstructionSet.QASM,
         ):
             raise ClassiqValueError("Only QASM or Q# programs support arguments")
 
-        if values.get("syntax") == QuantumInstructionSet.QSHARP and len(arguments) > 1:
+        if (
+            info.data.get("syntax") == QuantumInstructionSet.QSHARP
+            and len(arguments) > 1
+        ):
             raise ClassiqValueError(
                 f"Q# programs supports only one group of arguments. {len(arguments)} given"
             )
 
         return arguments
 
-    @pydantic.validator("synthesis_execution_data")
+    @pydantic.field_validator("synthesis_execution_data")
+    @classmethod
     def validate_synthesis_execution_data(
         cls,
         synthesis_execution_data: Optional[ExecutionData],
-        values: Dict[str, Any],
+        values: ValidationInfo,
     ) -> Optional[ExecutionData]:
         if (
             synthesis_execution_data is not None
-            and values.get("syntax") is not QuantumInstructionSet.QASM
+            and values.data.get("syntax") is not QuantumInstructionSet.QASM
         ):
             raise ClassiqValueError("Only QASM supports the requested configuration")