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

classiq/interface/generator/control_state.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from typing import Any, Dict
 
 import pydantic
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
@@ -18,45 +18,52 @@ class ControlState(BaseModel):
         default=_DEFAULT_NUM_CONTROL_QUBITS, description="Number of control qubits"
     )
     ctrl_state: str = pydantic.Field(
-        default=_INVALID_CONTROL_STATE, description="Control state string"
+        default=_INVALID_CONTROL_STATE,
+        description="Control state string",
+        validate_default=True,
+    )
+    name: str = pydantic.Field(
+        default=_DEFAULT_CONTROL_NAME, description="Control name"
     )
-    name: str = pydantic.Field(default=None, description="Control name")
 
-    @pydantic.root_validator()
-    def _validate_control(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        num_ctrl_qubits: int = values.get(
-            "num_ctrl_qubits", _DEFAULT_NUM_CONTROL_QUBITS
-        )
-        ctrl_state: str = values.get("ctrl_state", _INVALID_CONTROL_STATE)
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _validate_control(cls, values: Any) -> Dict[str, Any]:
+        if isinstance(values, dict):
+            num_ctrl_qubits: int = (
+                values.get("num_ctrl_qubits", _DEFAULT_NUM_CONTROL_QUBITS) or 0
+            )
 
-        if ctrl_state == _INVALID_CONTROL_STATE:
-            ctrl_state = "1" * num_ctrl_qubits
-            values["ctrl_state"] = ctrl_state
+            ctrl_state: str = values.get("ctrl_state") or _INVALID_CONTROL_STATE
 
-        cls.validate_control_string(ctrl_state)
+            if ctrl_state == _INVALID_CONTROL_STATE:
+                ctrl_state = "1" * num_ctrl_qubits
+                values["ctrl_state"] = ctrl_state
 
-        if num_ctrl_qubits == _DEFAULT_NUM_CONTROL_QUBITS:
-            num_ctrl_qubits = len(ctrl_state)
-            values["num_ctrl_qubits"] = num_ctrl_qubits
+            cls.validate_control_string(ctrl_state)
 
-        if len(ctrl_state) != num_ctrl_qubits:
-            raise ClassiqValueError(
-                "Control state length should be equal to the number of control qubits"
-            )
+            if num_ctrl_qubits == _DEFAULT_NUM_CONTROL_QUBITS:
+                num_ctrl_qubits = len(ctrl_state)
+                values["num_ctrl_qubits"] = num_ctrl_qubits
+
+            if len(ctrl_state) != num_ctrl_qubits:
+                raise ClassiqValueError(
+                    "Control state length should be equal to the number of control qubits"
+                )
 
-        if values.get("name") is None:
-            values["name"] = f"{_DEFAULT_CONTROL_NAME}_{ctrl_state}"
+            if "name" not in values or values["name"] is None:
+                values["name"] = f"{_DEFAULT_CONTROL_NAME}_{ctrl_state}"
 
         return values
 
     @staticmethod
     def validate_control_string(ctrl_state: str) -> None:
+        if not ctrl_state:
+            raise ClassiqValueError("Control state cannot be empty")
         if not set(ctrl_state) <= {"1", "0"}:
             raise ClassiqValueError(
                 f"Control state can only be constructed from 0 and 1, received: {ctrl_state}"
             )
-        if not ctrl_state:
-            raise ClassiqValueError("Control state cannot be empty")
 
     def __str__(self) -> str:
         return self.ctrl_state
@@ -71,5 +78,4 @@ class ControlState(BaseModel):
     def rename(self, name: str) -> ControlState:
         return ControlState(ctrl_state=self.ctrl_state, name=name)
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)

classiq/interface/generator/expressions/expression.py

@@ -3,7 +3,7 @@ import sys
 from typing import Any, Mapping, Optional, Type
 
 import pydantic
-from pydantic import PrivateAttr
+from pydantic import ConfigDict, PrivateAttr
 
 from classiq.interface.ast_node import HashableASTNode
 from classiq.interface.exceptions import ClassiqError
@@ -31,7 +31,8 @@ class Expression(HashableASTNode):
 
         self._try_to_immediate_evaluate()
 
-    @pydantic.validator("expr")
+    @pydantic.field_validator("expr")
+    @classmethod
     def validate_expression(cls, expr: str) -> str:
         supported_functions = (
             SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS_QMOD
@@ -41,7 +42,8 @@ class Expression(HashableASTNode):
         validate_expression_str(expr, supported_functions=supported_functions)
         return expr
 
-    @pydantic.validator("expr")
+    @pydantic.field_validator("expr")
+    @classmethod
     def format_expression(cls, expr: str) -> str:
         if sys.version_info >= (3, 9):
             expr = ast.unparse(ast.parse(expr))
@@ -97,8 +99,7 @@ class Expression(HashableASTNode):
     def is_constant(self) -> bool:
         return self.value.is_constant()
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
     def __str__(self) -> str:
         return self.expr

classiq/interface/generator/expressions/qmod_qscalar_proxy.py

@@ -29,10 +29,10 @@ class QmodQNumProxy(QmodQScalarProxy):
         self, handle: HandleBinding, size: int, fraction_digits: int, is_signed: bool
     ) -> None:
         super().__init__(handle, size)
-        if fraction_digits + is_signed > size:
+        if fraction_digits > size:
             raise ClassiqValueError(
-                f"{'Signed' if is_signed else 'Unsigned'} quantum numeric of size "
-                f"{size} cannot have {fraction_digits} fraction digits"
+                f"Quantum numeric of size {size} cannot have {fraction_digits} "
+                f"fraction digits"
             )
         self._fraction_digits = fraction_digits
         self._is_signed = is_signed

classiq/interface/generator/function_params.py

@@ -17,7 +17,8 @@ from typing import (
 
 import pydantic
 import sympy
-from pydantic.fields import ModelField
+from pydantic import BeforeValidator, ConfigDict
+from typing_extensions import Annotated
 
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.exceptions import ClassiqValueError
@@ -25,6 +26,7 @@ from classiq.interface.generator.arith.arithmetic_expression_validator import (
     validate_expression,
 )
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
+from classiq.interface.generator.parameters import ParameterFloatType
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
 from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
@@ -126,6 +128,22 @@ def validate_expression_str(
     )
 
 
+def validate_parameters(value: Any) -> Any:
+    if isinstance(value, str):
+        validate_expression_str(value)
+    elif isinstance(value, sympy.Expr):
+        return str(value)
+    try:
+        return float(value)
+    except ValueError:
+        return value
+
+
+FunctionParamsNumericParameter = Annotated[
+    ParameterFloatType, BeforeValidator(validate_parameters)
+]
+
+
 class PortDirection(StrEnum):
     Input = "input"
     Output = "output"
@@ -197,20 +215,6 @@ class FunctionParams(HashablePydanticBaseModel):
         if self.discriminator() not in _UNVALIDATED_FUNCTIONS:
             self._validate_total_io_sizes()
 
-    def is_field_param_type(self, name: str, param_type_signature: str) -> bool:
-        f = type(self).__fields__[name]
-        return isinstance(f, ModelField) and (
-            param_type_signature in f.field_info.extra
-        )
-
-    def is_field_gen_param(self, name: str) -> bool:
-        return self.is_field_param_type(
-            name, "is_gen_param"
-        ) or self.is_field_exec_param(name)
-
-    def is_field_exec_param(self, name: str) -> bool:
-        return self.is_field_param_type(name, "is_exec_param")
-
     def is_powerable(self, strict_zero_ios: bool = True) -> bool:
         input_names = set(self.inputs_full(strict_zero_ios))
         output_names = set(self._output_names)
@@ -261,28 +265,7 @@ class FunctionParams(HashablePydanticBaseModel):
     def discriminator(cls) -> FunctionParamsDiscriminator:
         return cls.__name__
 
-    @property
-    def _params(self) -> List[str]:
-        return [
-            name
-            for name, field in self.__fields__.items()
-            if field.field_info.extra.get("is_exec_param", False)
-        ]
-
-    @pydantic.validator("*", pre=True)
-    def validate_parameters(cls, value: Any, field: pydantic.fields.ModelField) -> Any:
-        if (
-            "is_exec_param" in field.field_info.extra
-            or "is_gen_param" in field.field_info.extra
-        ):
-            if isinstance(value, str):
-                validate_expression_str(value)
-            elif isinstance(value, sympy.Expr):
-                return str(value)
-        return value
-
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True, extra="forbid")
 
 
 def parse_function_params(
@@ -306,12 +289,12 @@ def parse_function_params(
     if len(matching_classes) != 1:
         if default_parser_class is not None:
             try:
-                return default_parser_class.parse_obj(params)
+                return default_parser_class.model_validate(params)
             except Exception:
                 raise bad_function_error from None
         raise bad_function_error
 
-    return matching_classes[0].parse_obj(params)
+    return matching_classes[0].model_validate(params)
 
 
 def parse_function_params_values(

classiq/interface/generator/functions/classical_function_declaration.py

@@ -40,4 +40,4 @@ class ClassicalFunctionDeclaration(FunctionDeclaration):
         return self.positional_parameters
 
 
-ClassicalFunctionDeclaration.update_forward_refs()
+ClassicalFunctionDeclaration.model_rebuild()

classiq/interface/generator/functions/classical_type.py

@@ -1,7 +1,7 @@
 from typing import TYPE_CHECKING, Any, Dict, List, Literal, Union
 
 import pydantic
-from pydantic import Extra
+from pydantic import ConfigDict
 from sympy import IndexedBase, Symbol
 
 from classiq.interface.ast_node import HashableASTNode
@@ -22,8 +22,7 @@ class ClassicalType(HashableASTNode):
     def as_symbolic(self, name: str) -> Union[NamedSymbol, List[NamedSymbol]]:
         return Symbol(name)
 
-    class Config:
-        extra = Extra.forbid
+    model_config = ConfigDict(extra="forbid")
 
     def __str__(self) -> str:
         return str(type(self).__name__)
@@ -35,8 +34,9 @@ class Integer(ClassicalType):
     def as_symbolic(self, name: str) -> Symbol:
         return Symbol(name, integer=True)
 
-    @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", "int")
 
 
@@ -46,16 +46,18 @@ class Real(ClassicalType):
     def as_symbolic(self, name: str) -> Symbol:
         return Symbol(name, real=True)
 
-    @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", "real")
 
 
 class Bool(ClassicalType):
     kind: Literal["bool"]
 
-    @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", "bool")
 
 
@@ -66,16 +68,18 @@ class ClassicalList(ClassicalType):
     def as_symbolic(self, name: str) -> Symbol:
         return IndexedBase(name)
 
-    @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", "list")
 
 
 class StructMetaType(ClassicalType):
     kind: Literal["type_proxy"]
 
-    @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", "type_proxy")
 
 
@@ -87,8 +91,9 @@ class ClassicalArray(ClassicalType):
     def as_symbolic(self, name: str) -> list:
         return [self.element_type.as_symbolic(f"{name}_{i}") for i in range(self.size)]
 
-    @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", "array")
 
 
@@ -99,32 +104,36 @@ class OpaqueHandle(ClassicalType):
 class VQEResult(OpaqueHandle):
     kind: Literal["vqe_result"]
 
-    @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", "vqe_result")
 
 
 class Histogram(OpaqueHandle):
     kind: Literal["histogram"]
 
-    @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", "histogram")
 
 
 class Estimation(OpaqueHandle):
     kind: Literal["estimation_result"]
 
-    @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", "estimation_result")
 
 
 class IQAERes(OpaqueHandle):
     kind: Literal["iqae_result"]
 
-    @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", "iqae_result")
 
 

classiq/interface/generator/functions/concrete_types.py

@@ -40,16 +40,17 @@ ConcreteClassicalType = Annotated[
     ],
     Field(discriminator="kind"),
 ]
-ClassicalList.update_forward_refs(ConcreteClassicalType=ConcreteClassicalType)
-ClassicalArray.update_forward_refs(ConcreteClassicalType=ConcreteClassicalType)
+ClassicalList.model_rebuild()
+ClassicalArray.model_rebuild()
 
-PythonClassicalTypes = (int, float, bool, list, Enum)
+NativePythonClassicalTypes = (int, float, bool, list)
+PythonClassicalPydanticTypes = (Enum,)
 
 ConcreteQuantumType = Annotated[
     Union[QuantumBit, QuantumBitvector, QuantumNumeric, TypeName],
     Field(discriminator="kind", default_factory=QuantumBitvector),
 ]
-QuantumBitvector.update_forward_refs(ConcreteQuantumType=ConcreteQuantumType)
-TypeName.update_forward_refs(ConcreteQuantumType=ConcreteQuantumType)
-QStructDeclaration.update_forward_refs(ConcreteQuantumType=ConcreteQuantumType)
-RegisterQuantumType.update_forward_refs(ConcreteQuantumType=ConcreteQuantumType)
+QuantumBitvector.model_rebuild()
+TypeName.model_rebuild()
+QStructDeclaration.model_rebuild()
+RegisterQuantumType.model_rebuild()

classiq/interface/generator/functions/function_declaration.py

@@ -1,7 +1,7 @@
 import abc
 from typing import Sequence
 
-import pydantic
+from pydantic import ConfigDict
 
 from classiq.interface.model.classical_parameter_declaration import (
     AnonClassicalParameterDeclaration,
@@ -16,11 +16,10 @@ class FunctionDeclaration(Parameter, abc.ABC):
 
     @property
     @abc.abstractmethod
-    def param_decls(self) -> Sequence[AnonClassicalParameterDeclaration]:
+    def param_decls(self) -> Sequence["AnonClassicalParameterDeclaration"]:
         pass
 
-    class Config:
-        extra = pydantic.Extra.forbid
+    model_config = ConfigDict(extra="forbid")
 
 
-FunctionDeclaration.update_forward_refs()
+FunctionDeclaration.model_rebuild()

classiq/interface/generator/functions/type_name.py

@@ -16,15 +16,16 @@ if TYPE_CHECKING:
     from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 
 
-class TypeName(ClassicalType, QuantumType):  # type:ignore[misc]
+class TypeName(ClassicalType, QuantumType):
     kind: Literal["struct_instance"]
     name: str = pydantic.Field(description="The type name of the instance")
     _assigned_fields: Optional[Mapping[str, "ConcreteQuantumType"]] = (
         pydantic.PrivateAttr(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", "struct_instance")
 
     def _update_size_in_bits_from_declaration(self) -> None:
@@ -60,7 +61,7 @@ class TypeName(ClassicalType, QuantumType):  # type:ignore[misc]
         if self._assigned_fields is None:
             qstruct_fields = QMODULE.qstruct_decls[self.name].fields
             self._assigned_fields = {
-                field_name: field_type.copy()
+                field_name: field_type.model_copy()
                 for field_name, field_type in qstruct_fields.items()
             }
 

classiq/interface/generator/generated_circuit_data.py

@@ -2,6 +2,7 @@ import logging
 from typing import Any, Dict, List, Literal, Optional, Tuple, Union
 
 import pydantic
+from pydantic import ConfigDict
 from typing_extensions import TypeAlias
 
 from classiq.interface.generator.control_state import ControlState
@@ -56,8 +57,8 @@ class GeneratedFunction(pydantic.BaseModel):
     name: str
     control_states: List[ControlState]
     registers: List[GeneratedRegister] = list()
-    depth: Optional[int]
-    width: Optional[int]
+    depth: Optional[int] = pydantic.Field(default=None)
+    width: Optional[int] = pydantic.Field(default=None)
     released_auxiliary_qubits: List[int] = list()
     dangling_inputs: Dict[str, GeneratedRegister] = dict()
     dangling_outputs: Dict[str, GeneratedRegister] = dict()
@@ -97,16 +98,18 @@ class GeneratedCircuitData(pydantic.BaseModel):
 
 
 class FunctionDebugInfoInterface(pydantic.BaseModel):
-    generated_function: Optional[GeneratedFunction]
+    generated_function: Optional[GeneratedFunction] = pydantic.Field(default=None)
     children: List["FunctionDebugInfoInterface"]
     relative_qubits: Tuple[int, ...]
-    absolute_qubits: Optional[Tuple[int, ...]]
-    is_basis_gate: Optional[bool]
+    absolute_qubits: Optional[Tuple[int, ...]] = pydantic.Field(default=None)
+    is_basis_gate: Optional[bool] = pydantic.Field(default=None)
     is_inverse: bool = pydantic.Field(default=False)
     is_allocate_or_free: bool = pydantic.Field(default=False)
     level: OperationLevel = pydantic.Field(default=OperationLevel.UNKNOWN)
     parameters: List[OperationParameter] = list()
-    port_to_passed_variable_map: Dict[str, str] = pydantic.Field(default_factory=dict)
+    port_to_passed_variable_map: Dict[str, str] = pydantic.Field(default={})
+
+    model_config = ConfigDict(extra="allow")
     # Temporary field to store the override debug info for parallel old/new visualization
     override_debug_info: Optional["FunctionDebugInfoInterface"] = None
 

classiq/interface/generator/grover_diffuser.py

@@ -1,6 +1,7 @@
 from typing import Any, Dict, List, Set, Tuple, 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
@@ -29,28 +30,34 @@ class GroverDiffuser(FunctionParams):
         self._inputs = {reg.name: reg for reg in self.variables}
         self._outputs = {reg.name: reg for reg in self.variables}
 
-    @pydantic.root_validator(pre=True)
-    def _validate_state_preparation_name(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        if isinstance(
-            values.get("state_preparation_params"), CustomFunction
-        ) and not values.get("state_preparation"):
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _validate_state_preparation_name(cls, values: Any) -> Dict[str, Any]:
+        if (
+            isinstance(values, dict)
+            and isinstance(values.get("state_preparation_params"), CustomFunction)
+            and not values.get("state_preparation")
+        ):
             raise ClassiqValueError(
                 "Must receive the function name from the `state_preparation` field for user defined functions"
             )
         return values
 
-    @pydantic.root_validator(pre=True)
-    def _parse_state_preparation(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        parse_function_params_values(
-            values=values,
-            params_key="state_preparation_params",
-            discriminator_key="state_preparation",
-            param_classes={StatePreparation, CustomFunction},
-            default_parser_class=CustomFunction,
-        )
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _parse_state_preparation(cls, values: Any) -> Dict[str, Any]:
+        if isinstance(values, dict):
+            parse_function_params_values(
+                values=values,
+                params_key="state_preparation_params",
+                discriminator_key="state_preparation",
+                param_classes={StatePreparation, CustomFunction},
+                default_parser_class=CustomFunction,
+            )
         return values
 
-    @pydantic.validator("variables")
+    @pydantic.field_validator("variables")
+    @classmethod
     def _validate_variables(
         cls, variables: List[RegisterUserInput]
     ) -> List[RegisterUserInput]:
@@ -58,11 +65,12 @@ class GroverDiffuser(FunctionParams):
         assert len(variables) == len(names), "Repeating names not allowed"
         return variables
 
-    @pydantic.validator("state_preparation_params")
+    @pydantic.field_validator("state_preparation_params")
+    @classmethod
     def _validate_state_preparation(
-        cls, state_preparation_params: GroverStatePreparation, values: Dict[str, Any]
+        cls, state_preparation_params: GroverStatePreparation, info: ValidationInfo
     ) -> GroverStatePreparation:
-        variables = values.get("variables", list())
+        variables = info.data.get("variables", list())
         sp_inputs = state_preparation_params.inputs_full(strict_zero_ios=False)
         sp_outputs = state_preparation_params.outputs
         if len(sp_inputs) == 1 and len(sp_outputs) == 1: