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

classiq/interface/generator/quantum_program.py

@@ -59,13 +59,15 @@ def _get_formatted_utc_current_time() -> str:
 
 class QuantumProgram(VersionedModel, CircuitCodeInterface):
     hardware_data: SynthesisHardwareData
-    initial_values: Optional[InitialConditions]
+    initial_values: Optional[InitialConditions] = pydantic.Field(default=None)
     data: GeneratedCircuitData
     model: ExecutionModel
-    transpiled_circuit: Optional[TranspiledCircuitData]
+    transpiled_circuit: Optional[TranspiledCircuitData] = pydantic.Field(default=None)
     creation_time: str = pydantic.Field(default_factory=_get_formatted_utc_current_time)
-    synthesis_duration: Optional[SynthesisStepDurations]
-    debug_info: Optional[List[FunctionDebugInfoInterface]]
+    synthesis_duration: Optional[SynthesisStepDurations] = pydantic.Field(default=None)
+    debug_info: Optional[List[FunctionDebugInfoInterface]] = pydantic.Field(
+        default=None
+    )
     program_id: str = pydantic.Field(default_factory=get_uuid_as_str)
     execution_primitives_input: Optional[PrimitivesInput] = pydantic.Field(default=None)
 
@@ -154,7 +156,7 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
             filename = f"synthesised_circuit_{self.creation_time}.json"
 
         with open(filename, "w") as file:
-            file.write(self.json(indent=4))
+            file.write(self.model_dump_json(indent=4))
 
     @classmethod
     def from_qprog(cls, qprog: str) -> "QuantumProgram":
@@ -167,7 +169,7 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
         Returns:
             QuantumProgram: The `QuantumProgram` instance.
         """
-        return cls.parse_raw(qprog)
+        return cls.model_validate_json(qprog)
 
     @property
     def _can_use_transpiled_code(self) -> bool:

classiq/interface/generator/range_types.py

@@ -1,8 +1,9 @@
 import math
-from typing import Any, Dict, Generic, Optional, TypeVar
+from typing import Generic, Optional, TypeVar
 
 import pydantic
-from pydantic.generics import GenericModel
+from pydantic import BaseModel, ConfigDict
+from typing_extensions import Self
 
 from classiq.interface.exceptions import ClassiqValueError
 
@@ -15,17 +16,15 @@ DEF_ATOL: float = 1e-08
 DEF_RTOL: float = 1e-05
 
 
-class Range(GenericModel, Generic[RangeType]):
+class Range(BaseModel, Generic[RangeType]):
     lower_bound: Optional[RangeType] = None
     upper_bound: Optional[RangeType] = None
+    model_config = ConfigDict(frozen=True)
 
-    class Config:
-        frozen = True
-
-    @pydantic.root_validator()
-    def _validate_bounds_order(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        lower_bound = values.get("lower_bound")
-        upper_bound = values.get("upper_bound")
+    @pydantic.model_validator(mode="after")
+    def _validate_bounds_order(self) -> Self:
+        lower_bound = self.lower_bound
+        upper_bound = self.upper_bound
 
         if (
             lower_bound is not None
@@ -34,7 +33,7 @@ class Range(GenericModel, Generic[RangeType]):
         ):
             raise ClassiqValueError("lower bound must not be greater than upper bound")
 
-        return values
+        return self
 
     def is_lower_bound_sat_by(
         self, value: float, atol: float = DEF_ATOL, rtol: float = DEF_RTOL

classiq/interface/generator/standard_gates/controlled_standard_gates.py

@@ -1,6 +1,7 @@
-from typing import Any, Dict, Literal, Optional, Union
+from typing import Literal, Optional, 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
@@ -48,14 +49,17 @@ class ControlledGateWithState(ControlledGate):  # type: ignore[misc]
     ctrl_state: CtrlState = pydantic.Field(
         description="The control state in decimal or as a bit string (e.g. '1011'). If not specified, the control "
         "state is 2**num_ctrl_qubits - 1.\n"
-        "The gate will be performed if the state of the control qubits matches the control state"
+        "The gate will be performed if the state of the control qubits matches the control state",
+        default=None,
+        validate_default=True,
     )
 
-    @pydantic.validator("ctrl_state", always=True)
+    @pydantic.field_validator("ctrl_state")
+    @classmethod
     def _validate_ctrl_state(
-        cls, ctrl_state: CtrlState, values: Dict[str, Any]
+        cls, ctrl_state: CtrlState, info: ValidationInfo
     ) -> CtrlState:
-        num_ctrl_qubits: int = values.get("num_ctrl_qubits", DEFAULT_NUM_CTRL_QUBITS)
+        num_ctrl_qubits: int = info.data.get("num_ctrl_qubits", DEFAULT_NUM_CTRL_QUBITS)
         ctrl_state = ctrl_state if ctrl_state is not None else "1" * num_ctrl_qubits
 
         if isinstance(ctrl_state, str) and len(ctrl_state) != num_ctrl_qubits:

classiq/interface/generator/standard_gates/standard_angle_metaclass.py

@@ -2,7 +2,7 @@ from typing import Any
 
 import pydantic
 
-from classiq.interface.generator.parameters import ParameterFloatType
+from classiq.interface.generator.function_params import FunctionParamsNumericParameter
 
 PydanticMetaClass: Any = type(pydantic.BaseModel)
 
@@ -16,14 +16,10 @@ class MyMetaAngledClass(type):
     @staticmethod
     def _create_new_namespace(namespace: dict, **kwargs: Any) -> dict:
         angles = kwargs.get("angles", [])
-        annotations = {angle: ParameterFloatType for angle in angles}
-        fields = {
-            angle: pydantic.fields.FieldInfo(is_exec_param=True) for angle in angles
-        }
+        annotations = {angle: FunctionParamsNumericParameter for angle in angles}
         original_annotations = namespace.get("__annotations__", {})
         return {
             **namespace,
-            **fields,
             **{"__annotations__": {**original_annotations, **annotations}},
         }
 

classiq/interface/generator/standard_gates/u_gate.py

@@ -2,7 +2,7 @@ import pydantic
 
 from classiq.interface.generator import function_params
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
-from classiq.interface.generator.parameters import ParameterFloatType
+from classiq.interface.generator.function_params import FunctionParamsNumericParameter
 from classiq.interface.generator.standard_gates.standard_gates import (
     DEFAULT_STANDARD_GATE_ARG_NAME,
 )
@@ -18,24 +18,20 @@ class UGate(function_params.FunctionParams):
     e^(i*phi)*sin(theta/2) & e^(i*(phi+lam))*cos(theta/2) \\
     """
 
-    theta: ParameterFloatType = pydantic.Field(
+    theta: FunctionParamsNumericParameter = pydantic.Field(
         description="Angle to rotate by the Y-axis.",
-        is_exec_param=True,
     )
 
-    phi: ParameterFloatType = pydantic.Field(
+    phi: FunctionParamsNumericParameter = pydantic.Field(
         description="First angle to rotate by the Z-axis.",
-        is_exec_param=True,
     )
 
-    lam: ParameterFloatType = pydantic.Field(
+    lam: FunctionParamsNumericParameter = pydantic.Field(
         description="Second angle to rotate by the Z-axis.",
-        is_exec_param=True,
     )
 
-    gam: ParameterFloatType = pydantic.Field(
+    gam: FunctionParamsNumericParameter = pydantic.Field(
         description="Angle to apply phase gate by.",
-        is_exec_param=True,
     )
 
     _inputs = pydantic.PrivateAttr(
@@ -56,5 +52,6 @@ class UGate(function_params.FunctionParams):
     @property
     def is_parametric(self) -> bool:
         return not all(
-            isinstance(getattr(self, angle), (float, int)) for angle in self._params
+            isinstance(getattr(self, angle), (float, int))
+            for angle in ["theta", "phi", "lam", "gam"]
         )

classiq/interface/generator/state_preparation/computational_basis_state_preparation.py

@@ -12,7 +12,8 @@ class ComputationalBasisStatePreparation(StatePreparationABC):
         description="binary computational state to create"
     )
 
-    @pydantic.validator("computational_state")
+    @pydantic.field_validator("computational_state")
+    @classmethod
     def _validate_computational_state(
         cls, computational_state: PydanticNonEmptyString
     ) -> PydanticNonEmptyString:

classiq/interface/generator/state_preparation/distributions.py

@@ -1,7 +1,8 @@
-from typing import Collection, Tuple, Union
+from typing import Collection, Sequence, Tuple, Union
 
 import pydantic
 from numpy.typing import ArrayLike
+from pydantic import ConfigDict
 
 from classiq.interface.generator.validations.validator_functions import (
     validate_probabilities,
@@ -11,20 +12,21 @@ from classiq.interface.helpers.custom_pydantic_types import PydanticProbabilityF
 
 class PMF(pydantic.BaseModel):
     pmf: Tuple[PydanticProbabilityFloat, ...]
-    _validate_amplitudes = pydantic.validator("pmf", allow_reuse=True)(
-        validate_probabilities
-    )
 
-    class Config:
-        frozen = True
+    @pydantic.field_validator("pmf")
+    @classmethod
+    def _validate_pmf(
+        cls, pmf: Tuple[PydanticProbabilityFloat, ...]
+    ) -> Sequence[PydanticProbabilityFloat]:
+        return validate_probabilities(cls, pmf)
+
+    model_config = ConfigDict(frozen=True)
 
 
 class GaussianMoments(pydantic.BaseModel):
     mu: float
     sigma: pydantic.PositiveFloat
-
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
 
 class GaussianMixture(pydantic.BaseModel):
@@ -32,9 +34,7 @@ class GaussianMixture(pydantic.BaseModel):
     num_qubits: pydantic.PositiveInt = pydantic.Field(
         description="Number of qubits for the provided state."
     )
-
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
 
 Probabilities = Union[PMF, GaussianMixture]

classiq/interface/generator/state_preparation/state_preparation.py

@@ -1,7 +1,9 @@
-from typing import Any, Dict, Optional, Union
+from typing import Dict, Optional, Union
 
 import numpy as np
 import pydantic
+from pydantic_core.core_schema import ValidationInfo
+from typing_extensions import Self
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.range_types import NonNegativeFloatRange
@@ -25,10 +27,14 @@ from classiq.interface.generator.validations.validator_functions import (
 
 class StatePreparation(StatePreparationABC):
     amplitudes: Optional[Amplitudes] = pydantic.Field(
-        description="vector of probabilities", default=None
+        description="vector of probabilities",
+        default=None,
+        validate_default=True,
     )
     probabilities: Optional[Probabilities] = pydantic.Field(
-        description="vector of amplitudes", default=None
+        description="vector of amplitudes",
+        default=None,
+        validate_default=True,
     )
     error_metric: Dict[Metrics, NonNegativeFloatRange] = pydantic.Field(
         default_factory=lambda: {
@@ -37,7 +43,8 @@ class StatePreparation(StatePreparationABC):
     )
     # The order of validations is important: amplitudes, probabilities, error_metric
 
-    @pydantic.validator("amplitudes", always=True, pre=True)
+    @pydantic.field_validator("amplitudes", mode="before")
+    @classmethod
     def _initialize_amplitudes(
         cls, amplitudes: Optional[FlexibleAmplitudes]
     ) -> Optional[Amplitudes]:
@@ -51,7 +58,8 @@ class StatePreparation(StatePreparationABC):
             "Invalid amplitudes were given, please ensure the amplitude is a vector of float in the form of either tuple or list or numpy array"
         )
 
-    @pydantic.validator("probabilities", always=True, pre=True)
+    @pydantic.field_validator("probabilities", mode="before")
+    @classmethod
     def _initialize_probabilities(
         cls, probabilities: Optional[FlexibleProbabilities]
     ) -> Optional[Union[PMF, GaussianMixture, dict]]:
@@ -69,11 +77,12 @@ class StatePreparation(StatePreparationABC):
             "Invalid probabilities were given, please ensure the probabilities is a vector of float in the form of either tuple or list or numpy array"
         )
 
-    @pydantic.validator("error_metric", always=True, pre=True)
+    @pydantic.field_validator("error_metric", mode="before")
+    @classmethod
     def _validate_error_metric(
-        cls, error_metric: Dict[Metrics, NonNegativeFloatRange], values: Dict[str, Any]
+        cls, error_metric: Dict[Metrics, NonNegativeFloatRange], info: ValidationInfo
     ) -> Dict[Metrics, NonNegativeFloatRange]:
-        if not values.get("amplitudes"):
+        if not info.data.get("amplitudes"):
             return error_metric
         unsupported_metrics = {
             Metrics(metric).value
@@ -86,18 +95,15 @@ class StatePreparation(StatePreparationABC):
             )
         return error_metric
 
-    @pydantic.root_validator
-    def _validate_either_probabilities_or_amplitudes(
-        cls,
-        values: Dict[str, Any],
-    ) -> Optional[Union[PMF, GaussianMixture, dict]]:
-        amplitudes = values.get("amplitudes")
-        probabilities = values.get("probabilities")
+    @pydantic.model_validator(mode="after")
+    def _validate_either_probabilities_or_amplitudes(self) -> Self:
+        amplitudes = self.amplitudes
+        probabilities = self.probabilities
         if amplitudes is not None and probabilities is not None:
             raise ClassiqValueError(
                 "StatePreparation can't get both probabilities and amplitudes"
             )
-        return values
+        return self
 
     @property
     def num_state_qubits(self) -> int:

classiq/interface/generator/types/enum_declaration.py

@@ -16,7 +16,8 @@ class EnumDeclaration(HashableASTNode):
         description="Dictionary of member names and their values",
     )
 
-    @pydantic.validator("members")
+    @pydantic.field_validator("members")
+    @classmethod
     def _validate_members(cls, members: Dict[str, int]) -> Dict[str, int]:
         underscore_members = [
             member for member in members.keys() if member.startswith("_")

classiq/interface/generator/ucc.py

@@ -41,7 +41,8 @@ class UCC(ChemistryFunctionParams):
         description="Prefix for the generated parameters",
     )
 
-    @pydantic.validator("excitations")
+    @pydantic.field_validator("excitations")
+    @classmethod
     def _validate_excitations(cls, excitations: EXCITATIONS_TYPE) -> EXCITATIONS_TYPE:
         if isinstance(excitations, int):
             if excitations not in _EXCITATIONS_DICT.values():

classiq/interface/generator/unitary_gate.py

@@ -25,7 +25,8 @@ class UnitaryGate(function_params.FunctionParams):
     )
 
     # TODO - decide if to include assertion on the unitarity of the matrix. It is already done in Qiskit and could be computationally expensive
-    @pydantic.validator("data")
+    @pydantic.field_validator("data")
+    @classmethod
     def validate_data(cls, data: DataArray) -> DataArray:
         data_np = np.array(data, dtype=object)
         if data_np.ndim != 2:

classiq/interface/generator/user_defined_function_params.py

@@ -1,6 +1,7 @@
 from typing import Mapping
 
 import pydantic
+from pydantic import ConfigDict
 
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.function_params import ArithmeticIODict, FunctionParams
@@ -11,6 +12,8 @@ class CustomFunction(FunctionParams):
     A user-defined custom function parameters object.
     """
 
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
     _name: str = pydantic.PrivateAttr(default="")
 
     input_decls: ArithmeticIODict = pydantic.Field(

classiq/interface/generator/visitor.py

@@ -102,7 +102,7 @@ class Transformer(Visitor):
             if name not in fields_to_skip:
                 result[name] = self.visit(value)
 
-        return node.copy(update=result)
+        return node.model_copy(update=result)
 
     def visit_int(self, n: int) -> int:
         return n

classiq/interface/hardware.py

@@ -2,9 +2,20 @@ import datetime
 from typing import TYPE_CHECKING, List, Optional, Tuple
 
 import pydantic
+from typing_extensions import Annotated
 
 from classiq.interface.enum_utils import StrEnum
 
+QueueTime = Annotated[
+    Optional[datetime.timedelta],
+    pydantic.PlainSerializer(
+        lambda _timedelta: (
+            _timedelta.total_seconds() if _timedelta is not None else None
+        ),
+        return_type=Optional[float],
+    ),
+]
+
 
 class Provider(StrEnum):
     """
@@ -22,6 +33,7 @@ class Provider(StrEnum):
     OQC = "OQC"
     INTEL = "Intel"
     AQT = "AQT"
+    IQCC = "IQCC"
 
     @property
     def id(self) -> "ProviderIDEnum":
@@ -55,8 +67,11 @@ class HardwareStatus(pydantic.BaseModel):
         default_factory=lambda: datetime.datetime.now(tz=datetime.UTC)
     )
     availability: AvailabilityStatus
-    queue_time: Optional[datetime.timedelta]
-    pending_jobs: Optional[int]
+    queue_time: QueueTime = pydantic.Field(
+        default=None,
+        description="The estimated queue time for the hardware in seconds.",
+    )
+    pending_jobs: Optional[int] = None
 
 
 if TYPE_CHECKING:
@@ -72,7 +87,7 @@ class HardwareInformation(pydantic.BaseModel):
     display_name: str
     device_type: DeviceType
     number_of_qubits: int
-    connectivity_map: Optional[List[ConnectivityMapEntry]]
+    connectivity_map: Optional[List[ConnectivityMapEntry]] = None
     basis_gates: List[str]
     status: HardwareStatus
 

classiq/interface/helpers/custom_pydantic_types.py

@@ -1,6 +1,8 @@
 from typing import TYPE_CHECKING, Any, List, Tuple
 
 import pydantic
+from pydantic import Field, StrictStr, StringConstraints
+from typing_extensions import Annotated
 
 from classiq.interface.generator.arith.number_utils import MAXIMAL_MACHINE_PRECISION
 from classiq.interface.generator.parameters import ParameterComplexType
@@ -13,13 +15,9 @@ if TYPE_CHECKING:
     PydanticLargerThanOneInteger = int
     PydanticMachinePrecision = int
 else:
+    PydanticLargerThanOneInteger = Annotated[int, Field(gt=1)]
 
-    class PydanticLargerThanOneInteger(pydantic.ConstrainedInt):
-        gt = 1
-
-    class PydanticMachinePrecision(pydantic.ConstrainedInt):
-        gt = 0
-        le = MAXIMAL_MACHINE_PRECISION
+    PydanticMachinePrecision = Annotated[int, Field(gt=0, le=MAXIMAL_MACHINE_PRECISION)]
 
 
 # Probability float types
@@ -28,93 +26,86 @@ if TYPE_CHECKING:
     PydanticNonOneProbabilityFloat = float
     PydanticNonZeroProbabilityFloat = float
 else:
+    PydanticProbabilityFloat = Annotated[float, Field(ge=0.0, le=1.0)]
 
-    class PydanticProbabilityFloat(pydantic.ConstrainedFloat):
-        ge = 0.0
-        le = 1.0
-
-    class PydanticNonOneProbabilityFloat(pydantic.ConstrainedFloat):
-        ge = 0.0
-        lt = 1.0
+    PydanticNonOneProbabilityFloat = Annotated[float, Field(ge=0.0, lt=1.0)]
 
-    class PydanticNonZeroProbabilityFloat(pydantic.ConstrainedFloat):
-        gt = 0.0
-        le = 1.0
+    PydanticNonZeroProbabilityFloat = Annotated[float, Field(gt=0.0, le=1.0)]
 
 
 # CVAR parameter types
 if TYPE_CHECKING:
     PydanticAlphaParamCVAR = float
 else:
-
-    class PydanticAlphaParamCVAR(pydantic.ConstrainedFloat):
-        gt = 0.0
-        le = 1.0
+    PydanticAlphaParamCVAR = Annotated[float, Field(gt=0.0, le=1.0)]
 
 
 # General string types
 if TYPE_CHECKING:
     PydanticNonEmptyString = str
 else:
-    PydanticNonEmptyString = pydantic.constr(min_length=1)
+    PydanticNonEmptyString = Annotated[str, Field(min_length=1)]
 
 # Name string types
 if TYPE_CHECKING:
     PydanticFunctionNameStr = str
 else:
-    PydanticFunctionNameStr = pydantic.constr(
-        strict=True, regex="^([A-Za-z][A-Za-z0-9_]*)$"
-    )
+    PydanticFunctionNameStr = Annotated[
+        str, Field(strict=True, pattern="^([A-Za-z][A-Za-z0-9_]*)$")
+    ]
 
 if TYPE_CHECKING:
     PydanticPauliMonomial = tuple
 else:
-    PydanticPauliMonomial = pydantic.conlist(item_type=Any, min_items=2, max_items=2)
+    PydanticPauliMonomial = Annotated[List[Any], Field(min_length=2, max_length=2)]
 
 if TYPE_CHECKING:
     PydanticPauliMonomialStr = str
 else:
-    PydanticPauliMonomialStr = pydantic.constr(
-        strict=True, strip_whitespace=True, min_length=1, regex="^[IXYZ]+$"
-    )
+    PydanticPauliMonomialStr = Annotated[
+        StrictStr,
+        StringConstraints(strip_whitespace=True, min_length=1, pattern="^[IXYZ]+$"),
+    ]
 
-if TYPE_CHECKING:
-    PydanticPauliList = List[Tuple[PydanticPauliMonomialStr, ParameterComplexType]]
-else:
-    PydanticPauliList = pydantic.conlist(item_type=tuple, min_items=1)
+PydanticPauliList = Annotated[
+    List[Tuple[PydanticPauliMonomialStr, ParameterComplexType]], Field(min_length=1)
+]
 
 if TYPE_CHECKING:
     PydanticFloatTuple = Tuple[float, float]
 else:
-    PydanticFloatTuple = pydantic.conlist(item_type=float, min_items=2, max_items=2)
+    PydanticFloatTuple = Annotated[List[float], Field(min_length=2, max_length=2)]
 
-if TYPE_CHECKING:
-    PydanticNonNegIntTuple = Tuple[pydantic.NonNegativeInt, pydantic.NonNegativeInt]
-else:
-    PydanticNonNegIntTuple = pydantic.conlist(
-        item_type=pydantic.NonNegativeInt, min_items=2, max_items=2
-    )
+PydanticNonNegIntTuple = Annotated[
+    List[pydantic.NonNegativeInt], Field(min_length=2, max_length=2)
+]
 
 if TYPE_CHECKING:
     PydanticExpressionStr = str
 else:
-    PydanticExpressionStr = pydantic.constr(
-        strip_whitespace=True, min_length=1, max_length=MAX_EXPRESSION_SIZE
-    )
+    PydanticExpressionStr = Annotated[
+        str,
+        StringConstraints(
+            strip_whitespace=True, min_length=1, max_length=MAX_EXPRESSION_SIZE
+        ),
+    ]
 if TYPE_CHECKING:
     AtomType = Tuple[str, List[float]]
 else:
-    AtomType = pydantic.conlist(item_type=Any, min_items=2, max_items=2)
+    AtomType = Annotated[List[Any], Field(min_length=2, max_length=2)]
 
 
 if TYPE_CHECKING:
     PydanticDataDogUuid = str
 else:
-    PydanticDataDogUuid = pydantic.constr(
-        regex=r"^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$"
-    )
+    PydanticDataDogUuid = Annotated[
+        str,
+        Field(
+            pattern=r"^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$"
+        ),
+    ]
 
 if TYPE_CHECKING:
     PydanticDataDogGo = int
 else:
-    PydanticDataDogGo = pydantic.conint(ge=0)
+    PydanticDataDogGo = Annotated[int, Field(ge=0)]

classiq/interface/helpers/pydantic_model_helpers.py

@@ -2,9 +2,10 @@ from typing import Any, Dict, Protocol, Sequence, TypeVar
 
 
 def values_with_discriminator(
-    values: Dict[str, Any], discriminator: str, discriminator_value: Any
+    values: Any, discriminator: str, discriminator_value: Any
 ) -> Dict[str, Any]:
-    values.setdefault(discriminator, discriminator_value)
+    if isinstance(values, dict):
+        values.setdefault(discriminator, discriminator_value)
     return values
 
 

classiq/interface/helpers/versioned_model.py

@@ -1,10 +1,7 @@
 import pydantic
 
 from classiq.interface._version import VERSION
-from classiq.interface.helpers.custom_encoders import CUSTOM_ENCODERS
 
 
-class VersionedModel(
-    pydantic.BaseModel, extra=pydantic.Extra.forbid, json_encoders=CUSTOM_ENCODERS
-):
+class VersionedModel(pydantic.BaseModel):
     version: str = pydantic.Field(default=VERSION)

classiq/interface/ide/ide_data.py

@@ -13,8 +13,8 @@ Depth = int
 
 class IDEDataQubit(pydantic.BaseModel):
     id: int
-    numChildren: Optional[int]
-    name: Optional[str]
+    numChildren: Optional[int] = None
+    name: Optional[str] = None
 
 
 class IDEQubitDef(pydantic.BaseModel):
@@ -75,9 +75,9 @@ class IDEDataOperation(pydantic.BaseModel):
 
 
 class IDEDataProperties(pydantic.BaseModel):
-    color: Optional[str]
-    rightLabel: Optional[str]
-    leftLabel: Optional[str]
+    color: Optional[str] = None
+    rightLabel: Optional[str] = None
+    leftLabel: Optional[str] = None
 
 
 class RegisterData(pydantic.BaseModel):