classiq 0.51.1__py3-none-any.whl → 0.53.0__py3-none-any.whl

classiq/interface/ide/visual_model.py

@@ -1,6 +1,7 @@
 from typing import Any, Dict, List, Optional, Tuple
 
 import pydantic
+from pydantic import ConfigDict
 
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.hardware.hardware_data import SynthesisHardwareData
@@ -23,7 +24,7 @@ class OperationType(StrEnum):
 
 
 class OperationData(pydantic.BaseModel):
-    approximated_depth: Optional[int]
+    approximated_depth: Optional[int] = None
     width: int
     gate_count: Dict[str, int] = pydantic.Field(default_factory=dict)
 
@@ -34,7 +35,7 @@ class ProgramData(pydantic.BaseModel):
 
 class OperationParameter(pydantic.BaseModel):
     label: str
-    value: Optional[str]
+    value: Optional[str] = None
 
 
 class OperationLink(pydantic.BaseModel):
@@ -43,8 +44,7 @@ class OperationLink(pydantic.BaseModel):
     qubits: Tuple[int, ...]
     type: str
 
-    class Config:
-        allow_mutation = False
+    model_config = ConfigDict(frozen=True)
 
     def __hash__(self) -> int:
         return hash((type(self), self.label, self.qubits, self.type))
@@ -59,6 +59,14 @@ class OperationLinks(pydantic.BaseModel):
     inputs: List[OperationLink]
     outputs: List[OperationLink]
 
+    @property
+    def input_width(self) -> int:
+        return sum(len(link.qubits) for link in self.inputs)
+
+    @property
+    def output_width(self) -> int:
+        return sum(len(link.qubits) for link in self.outputs)
+
 
 class AtomicGate(StrEnum):
     UNKNOWN = ""
@@ -89,12 +97,17 @@ class AtomicGate(StrEnum):
     CPHASE = "CPHASE"
     SWAP = "SWAP"
     IDENTITY = "IDENTITY"
+    U = "U"
+
+    @property
+    def is_control_gate(self) -> bool:
+        return self.startswith("C")
 
 
 class Operation(pydantic.BaseModel):
     name: str
     children: List["Operation"]
-    operation_data: Optional[OperationData]
+    operation_data: Optional[OperationData] = None
     operation_links: OperationLinks
     control_qubits: Tuple[int, ...] = pydantic.Field(default_factory=tuple)
     auxiliary_qubits: Tuple[int, ...]

classiq/interface/interface_version.py

@@ -1 +1 @@
-INTERFACE_VERSION = "3"
+INTERFACE_VERSION = "4"

classiq/interface/jobs.py

@@ -2,7 +2,7 @@ from typing import Any, Dict, Generic, Optional, TypeVar, Union
 
 import pydantic
 from pydantic import BaseModel
-from pydantic.generics import GenericModel
+from typing_extensions import Self
 
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.exceptions import ClassiqAPIError
@@ -41,33 +41,23 @@ For unsuccessful jobs, we expect failure_details to be a string and result to be
 """
 
 
-class JobDescription(GenericModel, Generic[T], json_encoders=CUSTOM_ENCODERS):
+class JobDescription(BaseModel, Generic[T], json_encoders=CUSTOM_ENCODERS):
     status: JobStatus
-    failure_details: Optional[str]
-    result: Optional[T]
+    failure_details: Optional[str] = pydantic.Field(default=None)
+    result: Optional[T] = pydantic.Field(default=None)
 
-    @pydantic.root_validator
-    def validate_status_and_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        status: Optional[JobStatus] = values.get("status")
-        if status is None or "result" not in values or "failure_details" not in values:
-            # If any of the fields doesn't exist, then previous validations failed
-            # result and failure_details are Optional, so we explicitly check if they
-            # exist in the values dictionary
-            return values
-
-        result = values["result"]
-        failure_details = values["failure_details"]
-
-        if status is JobStatus.COMPLETED:
+    @pydantic.model_validator(mode="after")
+    def validate_status_and_fields(self) -> Self:
+        if self.status is JobStatus.COMPLETED:
             # Completed job must return result and not have an error
-            if result is None or failure_details is not None:
+            if self.result is None or self.failure_details is not None:
                 raise ClassiqAPIError(INVALID_RESPONSE_ERROR_MSG)
-        elif status in (JobStatus.FAILED, JobStatus.CANCELLED):
+        elif self.status in (JobStatus.FAILED, JobStatus.CANCELLED):
             # Failed job must return error and not have result
-            if result is not None or failure_details is None:
+            if self.result is not None or self.failure_details is None:
                 raise ClassiqAPIError(INVALID_RESPONSE_ERROR_MSG)
-        elif result is not None or failure_details is not None:
+        elif self.result is not None or self.failure_details is not None:
             # Pending job must have no result and no error
             raise ClassiqAPIError(INVALID_RESPONSE_ERROR_MSG)
 
-        return values
+        return self

classiq/interface/model/bind_operation.py

@@ -49,7 +49,8 @@ class BindOperation(QuantumOperation):
             for handle in self.out_handles
         ]
 
-    @pydantic.validator("in_handles", "out_handles")
+    @pydantic.field_validator("in_handles", "out_handles")
+    @classmethod
     def validate_handle(cls, handles: List[HandleBinding]) -> List[HandleBinding]:
         for handle in handles:
             if not handle.is_bindable():

classiq/interface/model/classical_parameter_declaration.py

@@ -10,11 +10,11 @@ from classiq.interface.model.parameter import Parameter
 
 class AnonClassicalParameterDeclaration(Parameter):
     kind: Literal["ClassicalParameterDeclaration"]
-
     classical_type: ConcreteClassicalType
 
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> Dict[str, Any]:
         return values_with_discriminator(
             values, "kind", "ClassicalParameterDeclaration"
         )
@@ -25,7 +25,13 @@ class AnonClassicalParameterDeclaration(Parameter):
             ClassicalParameterDeclaration,
         ):
             raise ClassiqInternalError
-        return ClassicalParameterDeclaration(**{**self.__dict__, "name": new_name})
+        return ClassicalParameterDeclaration(
+            **{
+                **self.__dict__,
+                "name": new_name,
+                "kind": "ClassicalParameterDeclaration",
+            }
+        )
 
 
 class ClassicalParameterDeclaration(AnonClassicalParameterDeclaration):

classiq/interface/model/handle_binding.py

@@ -2,7 +2,7 @@ from itertools import chain
 from typing import TYPE_CHECKING, Any, Dict, Sequence, Union
 
 import pydantic
-from pydantic import Extra, Field
+from pydantic import ConfigDict, Field
 
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.generator.expressions.expression import Expression
@@ -12,10 +12,7 @@ HANDLE_ID_SEPARATOR = "___"
 
 class HandleBinding(ASTNode):
     name: str = Field(default=None)
-
-    class Config:
-        frozen = True
-        extra = Extra.forbid
+    model_config = ConfigDict(frozen=True, extra="forbid")
 
     def __str__(self) -> str:
         return self.name
@@ -52,10 +49,18 @@ class HandleBinding(ASTNode):
 class NestedHandleBinding(HandleBinding):
     base_handle: "ConcreteHandleBinding"
 
-    @pydantic.root_validator(pre=False)
-    def _set_name(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        if "base_handle" in values:
-            values["name"] = values["base_handle"].name
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_name(cls, values: Any) -> Dict[str, Any]:
+        if isinstance(values, dict):
+            orig = values
+            while "base_handle" in values:
+                values = values["base_handle"]
+            orig["name"] = dict(values).get("name")
+            return orig
+        if isinstance(values, NestedHandleBinding):
+            values.name = values.base_handle.name
+            return values.model_dump()
         return values
 
     def is_bindable(self) -> bool:
@@ -67,10 +72,7 @@ class NestedHandleBinding(HandleBinding):
 
 class SubscriptHandleBinding(NestedHandleBinding):
     index: Expression
-
-    class Config:
-        frozen = True
-        extra = Extra.forbid
+    model_config = ConfigDict(frozen=True, extra="forbid")
 
     def __str__(self) -> str:
         return f"{self.base_handle}[{self.index}]"
@@ -121,10 +123,7 @@ class SubscriptHandleBinding(NestedHandleBinding):
 class SlicedHandleBinding(NestedHandleBinding):
     start: Expression
     end: Expression
-
-    class Config:
-        frozen = True
-        extra = Extra.forbid
+    model_config = ConfigDict(frozen=True, extra="forbid")
 
     def __str__(self) -> str:
         return f"{self.base_handle}[{self.start}:{self.end}]"
@@ -191,10 +190,7 @@ class SlicedHandleBinding(NestedHandleBinding):
 
 class FieldHandleBinding(NestedHandleBinding):
     field: str
-
-    class Config:
-        frozen = True
-        extra = Extra.forbid
+    model_config = ConfigDict(frozen=True, extra="forbid")
 
     def __str__(self) -> str:
         return f"{self.base_handle}.{self.field}"
@@ -222,6 +218,6 @@ ConcreteHandleBinding = Union[
     SlicedHandleBinding,
     FieldHandleBinding,
 ]
-SubscriptHandleBinding.update_forward_refs(ConcreteHandleBinding=ConcreteHandleBinding)
-SlicedHandleBinding.update_forward_refs(ConcreteHandleBinding=ConcreteHandleBinding)
-FieldHandleBinding.update_forward_refs(ConcreteHandleBinding=ConcreteHandleBinding)
+SubscriptHandleBinding.model_rebuild()
+SlicedHandleBinding.model_rebuild()
+FieldHandleBinding.model_rebuild()

classiq/interface/model/inplace_binary_operation.py

@@ -1,7 +1,7 @@
-from typing import Literal, Mapping, Sequence
+from typing import Literal, Mapping, Sequence, Union
 
 from classiq.interface.enum_utils import StrEnum
-from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.handle_binding import ConcreteHandleBinding, HandleBinding
 from classiq.interface.model.quantum_statement import HandleMetadata, QuantumOperation
 
@@ -15,21 +15,28 @@ class InplaceBinaryOperation(QuantumOperation):
     kind: Literal["InplaceBinaryOperation"]
 
     target: ConcreteHandleBinding
-    value: ConcreteHandleBinding
+    value: Union[ConcreteHandleBinding, Expression]
     operation: BinaryOperation
 
     @property
     def wiring_inouts(self) -> Mapping[str, HandleBinding]:
-        return nameables_to_dict([self.target, self.value])
+        inouts = {self.target.name: self.target}
+        if isinstance(self.value, HandleBinding):
+            inouts[self.value.name] = self.value
+        return inouts
 
     @property
     def readable_inouts(self) -> Sequence[HandleMetadata]:
         suffix = f" of an in-place {self.operation.name.lower()} statement"
-        return [
+        readable_inouts = [
             HandleMetadata(
                 handle=self.target, readable_location=f"as the target{suffix}"
-            ),
-            HandleMetadata(
-                handle=self.value, readable_location=f"as the value{suffix}"
-            ),
+            )
         ]
+        if isinstance(self.value, HandleBinding):
+            readable_inouts.append(
+                HandleMetadata(
+                    handle=self.value, readable_location=f"as the value{suffix}"
+                )
+            )
+        return readable_inouts

classiq/interface/model/model.py

@@ -1,5 +1,5 @@
 from collections import Counter
-from typing import List, Literal, Mapping, NewType
+from typing import Any, List, Literal, Mapping, NewType
 
 import pydantic
 
@@ -61,6 +61,7 @@ class Model(VersionedModel, ASTNode):
     functions: List[NativeFunctionDefinition] = pydantic.Field(
         default_factory=list,
         description="The user-defined custom type library.",
+        validate_default=True,
     )
 
     enums: List[EnumDeclaration] = pydantic.Field(
@@ -105,9 +106,17 @@ class Model(VersionedModel, ASTNode):
     def body(self) -> StatementBlock:
         return self.main_func.body
 
-    @pydantic.validator("preferences", always=True)
-    def _seed_suffix_randomizer(cls, preferences: Preferences) -> Preferences:
-        SUFFIX_RANDOMIZER.seed(preferences.random_seed)
+    @pydantic.field_validator("preferences", mode="before")
+    @classmethod
+    def _seed_suffix_randomizer(cls, preferences: Any) -> Any:
+        if isinstance(preferences, dict):
+            SUFFIX_RANDOMIZER.seed(preferences.get("random_seed"))
+        elif isinstance(preferences, Preferences):
+            SUFFIX_RANDOMIZER.seed(preferences.random_seed)
+        else:
+            raise ClassiqValueError(
+                f"preferences must be either a dict or a Preferences object, not {type(preferences)}"
+            )
         return preferences
 
     def _get_qualified_direction(
@@ -121,7 +130,8 @@ class Model(VersionedModel, ASTNode):
     def function_dict(self) -> Mapping[str, NamedParamsQuantumFunctionDeclaration]:
         return nameables_to_dict(self.functions)
 
-    @pydantic.validator("functions", always=True)
+    @pydantic.field_validator("functions")
+    @classmethod
     def _add_empty_main(
         cls, functions: List[NativeFunctionDefinition]
     ) -> List[NativeFunctionDefinition]:
@@ -131,11 +141,10 @@ class Model(VersionedModel, ASTNode):
         return functions
 
     def get_model(self) -> SerializedModel:
-        return SerializedModel(
-            self.json(exclude_defaults=True, exclude_unset=True, indent=2)
-        )
+        return SerializedModel(self.model_dump_json(indent=2))
 
-    @pydantic.validator("functions")
+    @pydantic.field_validator("functions")
+    @classmethod
     def _validate_entry_point(
         cls, functions: List[NativeFunctionDefinition]
     ) -> List[NativeFunctionDefinition]:
@@ -150,7 +159,8 @@ class Model(VersionedModel, ASTNode):
 
         return functions
 
-    @pydantic.validator("constants")
+    @pydantic.field_validator("constants")
+    @classmethod
     def _validate_constants(cls, constants: List[Constant]) -> List[Constant]:
         constant_definition_counts = Counter(
             [constant.name for constant in constants]
@@ -166,7 +176,7 @@ class Model(VersionedModel, ASTNode):
         return constants
 
     def json_no_preferences_and_constraints(self) -> str:
-        return self.json(
+        return self.model_dump_json(
             indent=2,
             exclude={
                 "constraints",

classiq/interface/model/native_function_definition.py

@@ -10,6 +10,13 @@ if TYPE_CHECKING:
     from classiq.interface.model.statement_block import StatementBlock
 
 
+class FunctionSynthesisData(pydantic.BaseModel):
+    should_synthesize_separately: bool = pydantic.Field(
+        default=False,
+        description="Whether the function should be synthesized separately.",
+    )
+
+
 class NativeFunctionDefinition(NamedParamsQuantumFunctionDeclaration):
     """
     Facilitates the creation of a user-defined composite function
@@ -21,3 +28,6 @@ class NativeFunctionDefinition(NamedParamsQuantumFunctionDeclaration):
     body: "StatementBlock" = pydantic.Field(
         default_factory=list, description="List of function calls to perform."
     )
+    synthesis_data: FunctionSynthesisData = pydantic.Field(
+        default_factory=FunctionSynthesisData,
+    )

classiq/interface/model/port_declaration.py

@@ -1,6 +1,7 @@
-from typing import Any, Dict, Literal, Mapping
+from typing import Any, Dict, Literal
 
 import pydantic
+from pydantic_core.core_schema import ValidationInfo
 
 from classiq.interface.exceptions import ClassiqInternalError, ClassiqValueError
 from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
@@ -12,19 +13,21 @@ from classiq.interface.model.parameter import Parameter
 
 
 class AnonPortDeclaration(Parameter):
-    kind: Literal["PortDeclaration"]
-
     quantum_type: ConcreteQuantumType
     direction: PortDeclarationDirection
+    kind: Literal["PortDeclaration"]
 
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> Dict[str, Any]:
         return values_with_discriminator(values, "kind", "PortDeclaration")
 
-    @pydantic.validator("direction")
+    @pydantic.field_validator("direction", mode="before")
+    @classmethod
     def _direction_validator(
-        cls, direction: PortDeclarationDirection, values: Mapping[str, Any]
+        cls, direction: PortDeclarationDirection, info: ValidationInfo
     ) -> PortDeclarationDirection:
+        values = info.data
         if direction is PortDeclarationDirection.Output:
             quantum_type = values.get("quantum_type")
             if quantum_type is None:

classiq/interface/model/quantum_expressions/arithmetic_operation.py

@@ -1,6 +1,7 @@
 from typing import Dict, Literal, Mapping, Optional, Sequence
 
 import pydantic
+from pydantic_core.core_schema import ValidationInfo
 
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.arith.arithmetic import (
@@ -34,17 +35,18 @@ class ArithmeticOperation(QuantumAssignmentOperation):
     )
 
     operation_kind: ArithmeticOperationKind = pydantic.Field(
-        default=None,
+        default=None, validate_default=True
     )
 
-    @pydantic.validator("operation_kind", always=True)
+    @pydantic.field_validator("operation_kind", mode="before")
+    @classmethod
     def _propagate_inplace_result(
-        cls, operation_kind: Optional[ArithmeticOperationKind], values: dict
+        cls, operation_kind: Optional[ArithmeticOperationKind], info: ValidationInfo
     ) -> ArithmeticOperationKind:
         if operation_kind is None:
             operation_kind = (
                 ArithmeticOperationKind.InplaceXor
-                if values["inplace_result"]
+                if info.data["inplace_result"]
                 else ArithmeticOperationKind.Assignment
             )
         return operation_kind

classiq/interface/model/quantum_function_declaration.py

@@ -8,6 +8,8 @@ from typing import (
 )
 
 import pydantic
+from pydantic import SerializeAsAny
+from pydantic_core.core_schema import ValidationInfo
 from typing_extensions import Annotated
 
 from classiq.interface.exceptions import ClassiqInternalError
@@ -143,7 +145,7 @@ class AnonQuantumFunctionDeclaration(FunctionDeclaration):
                 **{
                     field_name: field_value
                     for field_name, field_value in self.__dict__.items()
-                    if field_name in AnonQuantumFunctionDeclaration.__fields__
+                    if field_name in AnonQuantumFunctionDeclaration.model_fields
                 },
                 "name": new_name,
             }
@@ -158,17 +160,21 @@ class AnonQuantumOperandDeclaration(AnonQuantumFunctionDeclaration):
         default=False,
     )
 
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> Dict[str, Any]:
         return values_with_discriminator(values, "kind", "QuantumOperandDeclaration")
 
     def rename(self, new_name: str) -> "QuantumOperandDeclaration":
         if type(self) not in (AnonQuantumOperandDeclaration, QuantumOperandDeclaration):
             raise ClassiqInternalError
-        return QuantumOperandDeclaration(**{**self.__dict__, "name": new_name})
+        new_instance_data = self.__dict__.copy()
+        new_instance_data["name"] = new_name
+        new_instance_data["kind"] = "QuantumOperandDeclaration"
+        return QuantumOperandDeclaration(**new_instance_data)
 
 
-AnonQuantumFunctionDeclaration.update_forward_refs()
+AnonQuantumFunctionDeclaration.model_rebuild()
 
 
 class QuantumFunctionDeclaration(AnonQuantumFunctionDeclaration):
@@ -176,16 +182,21 @@ class QuantumFunctionDeclaration(AnonQuantumFunctionDeclaration):
 
 
 class QuantumOperandDeclaration(
-    QuantumFunctionDeclaration, AnonQuantumOperandDeclaration
+    AnonQuantumOperandDeclaration, QuantumFunctionDeclaration
 ):
-    pass
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_none(cls, values: Any, info: ValidationInfo) -> Dict[str, Any]:
+        return values
 
 
 PositionalArg = Annotated[
-    Union[
-        ClassicalParameterDeclaration,
-        QuantumOperandDeclaration,
-        PortDeclaration,
+    SerializeAsAny[
+        Union[
+            ClassicalParameterDeclaration,
+            QuantumOperandDeclaration,
+            PortDeclaration,
+        ]
     ],
     pydantic.Field(..., discriminator="kind"),
 ]

classiq/interface/model/quantum_statement.py

@@ -3,7 +3,7 @@ from typing import Any, Callable, Dict, Mapping, Optional, Sequence
 from uuid import UUID, uuid4
 
 import pydantic
-from pydantic import Extra, root_validator
+from pydantic import ConfigDict
 
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
@@ -15,13 +15,12 @@ from classiq.interface.model.handle_binding import (
 
 class QuantumStatement(ASTNode):
     kind: str
+    model_config = ConfigDict(extra="forbid")
 
-    class Config:
-        extra = Extra.forbid
-
-    @root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        return values_with_discriminator(values, "kind", cls.__name__)  # type: ignore[attr-defined]
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> Dict[str, Any]:
+        return values_with_discriminator(values, "kind", cls.__name__)
 
 
 @dataclass

classiq/interface/model/quantum_type.py

@@ -1,7 +1,8 @@
 from typing import TYPE_CHECKING, Any, Dict, Literal, Optional
 
 import pydantic
-from pydantic import BaseModel, Extra, Field
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import Self
 
 from classiq.interface.ast_node import HashableASTNode
 from classiq.interface.exceptions import ClassiqValueError
@@ -25,8 +26,7 @@ if TYPE_CHECKING:
 
 
 class QuantumType(HashableASTNode):
-    class Config:
-        extra = Extra.forbid
+    model_config = ConfigDict(extra="forbid")
 
     _size_in_bits: Optional[int] = pydantic.PrivateAttr(default=None)
 
@@ -72,8 +72,9 @@ class QuantumBit(QuantumScalar):
         super().__init__(**kwargs)
         self._size_in_bits = 1
 
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> Dict[str, Any]:
         return values_with_discriminator(values, "kind", "qbit")
 
     @property
@@ -89,14 +90,15 @@ class QuantumBit(QuantumScalar):
 
 
 class QuantumBitvector(QuantumType):
-    kind: Literal["qvec"]
     element_type: "ConcreteQuantumType" = Field(
         discriminator="kind", default_factory=QuantumBit
     )
-    length: Optional[Expression]
+    kind: Literal["qvec"]
+    length: Optional[Expression] = Field(default=None)
 
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> Dict[str, Any]:
         return values_with_discriminator(values, "kind", "qvec")
 
     def _update_size_in_bits_from_declaration(self) -> None:
@@ -144,23 +146,24 @@ class QuantumBitvector(QuantumType):
 class QuantumNumeric(QuantumScalar):
     kind: Literal["qnum"]
 
-    size: Optional[Expression] = pydantic.Field()
-    is_signed: Optional[Expression] = pydantic.Field()
-    fraction_digits: Optional[Expression] = pydantic.Field()
+    size: Optional[Expression] = pydantic.Field(default=None)
+    is_signed: Optional[Expression] = pydantic.Field(default=None)
+    fraction_digits: Optional[Expression] = pydantic.Field(default=None)
 
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> Dict[str, Any]:
         return values_with_discriminator(values, "kind", "qnum")
 
-    @pydantic.root_validator
-    def _validate_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        has_sign = values["is_signed"] is not None
-        has_fraction_digits = values["fraction_digits"] is not None
+    @pydantic.model_validator(mode="after")
+    def _validate_fields(self) -> Self:
+        has_sign = self.is_signed is not None
+        has_fraction_digits = self.fraction_digits is not None
         if has_sign and not has_fraction_digits or not has_sign and has_fraction_digits:
             raise ClassiqValueError(
                 "Assign neither or both of is_signed and fraction_digits"
             )
-        return values
+        return self
 
     @property
     def has_sign(self) -> bool: