classiq 0.38.0__py3-none-any.whl → 0.40.0__py3-none-any.whl

classiq/interface/generator/functions/builtins/quantum_operators.py

@@ -0,0 +1,37 @@
+from typing import Any
+
+from classiq.interface.model.quantum_function_declaration import (
+    QuantumFunctionDeclaration,
+    QuantumOperandDeclaration,
+)
+
+
+def get_single_empty_operand_operator(
+    operator_name: str, **kwargs: Any
+) -> QuantumFunctionDeclaration:
+    operand_field_name = "operand"
+    return QuantumFunctionDeclaration(
+        name=operator_name,
+        operand_declarations={
+            operand_field_name: QuantumOperandDeclaration(name=operand_field_name)
+        },
+        **kwargs,
+    )
+
+
+PERMUTE_OPERATOR = QuantumFunctionDeclaration(
+    name="permute",
+    operand_declarations={
+        "functions": QuantumOperandDeclaration(
+            name="functions",
+            is_list=True,
+        )
+    },
+)
+
+APPLY_OPERATOR = get_single_empty_operand_operator(operator_name="apply")
+
+STD_QMOD_OPERATORS = [
+    PERMUTE_OPERATOR,
+    APPLY_OPERATOR,
+]

classiq/interface/generator/functions/classical_type.py

@@ -6,20 +6,22 @@ from pydantic import Extra, Field
 from sympy import IndexedBase, Symbol
 from typing_extensions import Annotated
 
+from classiq.interface.ast_node import HashableASTNode
 from classiq.interface.generator.expressions.enums.ladder_operator import (
     LadderOperator as LadderOperatorEnum,
 )
 from classiq.interface.generator.expressions.enums.pauli import Pauli as PauliEnum
 from classiq.interface.generator.expressions.expression_types import RuntimeExpression
-from classiq.interface.helpers.hashable_pydantic_base_model import (
-    HashablePydanticBaseModel,
-)
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 
+CLASSICAL_ATTRIBUTES = {
+    "len": len,
+}
+
 NamedSymbol = Union[IndexedBase, Symbol]
 
 
-class ClassicalType(HashablePydanticBaseModel):
+class ClassicalType(HashableASTNode):
     def as_symbolic(self, name: str) -> Union[NamedSymbol, List[NamedSymbol]]:
         return Symbol(name)
 
@@ -31,9 +33,9 @@ class ClassicalType(HashablePydanticBaseModel):
         )
 
     @property
-    def python_type(self) -> type:
+    def qmod_type(self) -> type:
         raise NotImplementedError(
-            f"{self.__class__.__name__!r} has no Python SDK equivalent"
+            f"{self.__class__.__name__!r} has no QMOD SDK equivalent"
         )
 
     class Config:
@@ -55,8 +57,10 @@ class Integer(ClassicalType):
         return values_with_discriminator(values, "kind", "int")
 
     @property
-    def python_type(self) -> type:
-        return int
+    def qmod_type(self) -> type:
+        from classiq.qmod.qmod_parameter import CInt
+
+        return CInt
 
 
 class Real(ClassicalType):
@@ -74,8 +78,10 @@ class Real(ClassicalType):
         return values_with_discriminator(values, "kind", "real")
 
     @property
-    def python_type(self) -> type:
-        return float
+    def qmod_type(self) -> type:
+        from classiq.qmod.qmod_parameter import CReal
+
+        return CReal
 
 
 class Bool(ClassicalType):
@@ -90,8 +96,10 @@ class Bool(ClassicalType):
         return values_with_discriminator(values, "kind", "bool")
 
     @property
-    def python_type(self) -> type:
-        return bool
+    def qmod_type(self) -> type:
+        from classiq.qmod.qmod_parameter import CBool
+
+        return CBool
 
 
 class ClassicalList(ClassicalType):
@@ -110,8 +118,10 @@ class ClassicalList(ClassicalType):
         return values_with_discriminator(values, "kind", "list")
 
     @property
-    def python_type(self) -> type:
-        return List[self.element_type.python_type]  # type:ignore[name-defined]
+    def qmod_type(self) -> type:
+        from classiq.qmod.qmod_parameter import CArray
+
+        return CArray[self.element_type.qmod_type]  # type:ignore[name-defined]
 
 
 class Pauli(ClassicalType):
@@ -126,8 +136,8 @@ class Pauli(ClassicalType):
         return values_with_discriminator(values, "kind", "pauli")
 
     @property
-    def python_type(self) -> type:
-        return int
+    def qmod_type(self) -> type:
+        return PauliEnum
 
 
 class StructMetaType(ClassicalType):
@@ -142,7 +152,7 @@ class StructMetaType(ClassicalType):
         return values_with_discriminator(values, "kind", "type_proxy")
 
 
-class QStructBase:  # marker for Qmod structs in the Python SDK
+class CStructBase:  # marker for Qmod structs in the Python SDK
     pass
 
 
@@ -159,8 +169,8 @@ class Struct(ClassicalType):
         return values_with_discriminator(values, "kind", "struct_instance")
 
     @property
-    def python_type(self) -> type:
-        return type(self.name, (QStructBase,), dict())
+    def qmod_type(self) -> type:
+        return type(self.name, (CStructBase,), dict())
 
 
 class ClassicalArray(ClassicalType):
@@ -230,8 +240,8 @@ class LadderOperator(ClassicalType):
         return values_with_discriminator(values, "kind", "ladder_operator")
 
     @property
-    def python_type(self) -> type:
-        return int
+    def qmod_type(self) -> type:
+        return LadderOperatorEnum
 
 
 ConcreteClassicalType = Annotated[

classiq/interface/generator/functions/function_declaration.py

@@ -2,12 +2,12 @@ import abc
 from typing import Dict
 
 import pydantic
-from pydantic.main import BaseModel
 
+from classiq.interface.ast_node import ASTNode
 from classiq.interface.generator.functions.classical_type import ConcreteClassicalType
 
 
-class FunctionDeclaration(BaseModel, abc.ABC):
+class FunctionDeclaration(ASTNode, abc.ABC):
     """
     Facilitates the creation of a common function interface object.
     """

classiq/interface/generator/hartree_fock.py

@@ -1,6 +1,12 @@
+from typing import Any, Union
+
 import pydantic
 
-from classiq.interface.chemistry.ground_state_problem import CHEMISTRY_PROBLEMS
+from classiq.interface.chemistry.ground_state_problem import (
+    CHEMISTRY_PROBLEMS,
+    HamiltonianProblem,
+    MoleculeProblem,
+)
 from classiq.interface.generator.chemistry_function_params import (
     ChemistryFunctionParams,
 )
@@ -10,7 +16,9 @@ from classiq.exceptions import ClassiqValueError
 
 class HartreeFock(ChemistryFunctionParams):
     @pydantic.validator("gs_problem")
-    def validate_gs_problem(cls, gs_problem):
+    def validate_gs_problem(
+        cls, gs_problem: Any
+    ) -> Union[MoleculeProblem, HamiltonianProblem]:
         if not isinstance(gs_problem, CHEMISTRY_PROBLEMS):
             raise ClassiqValueError(
                 f"ground state problem must be of type {CHEMISTRY_PROBLEMS}"

classiq/interface/generator/model/classical_main_validator.py

@@ -1,7 +1,7 @@
 import ast
 from typing import Dict, List
 
-from classiq.model.model import DEFAULT_RESULT_NAME
+from classiq.executor import DEFAULT_RESULT_NAME
 
 STANDARD_CMAIN_BODY_LENGTH = 2  # assignment of sample call, save statement
 

classiq/interface/generator/model/model.py

@@ -26,10 +26,10 @@ from classiq.interface.generator.types.struct_declaration import StructDeclarati
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.helpers.validation_helpers import is_list_unique
 from classiq.interface.helpers.versioned_model import VersionedModel
+from classiq.interface.model.quantum_register import QReg, QRegGenericAlias
 
 from classiq import ForeignFunctionDefinition as SynthesisForeignFunctionDefinition
 from classiq.exceptions import ClassiqValueError
-from classiq.quantum_register import QReg, QRegGenericAlias
 
 MAIN_FUNCTION_NAME = "main"
 CLASSICAL_ENTRY_FUNCTION_NAME = "cmain"

classiq/interface/generator/model/preferences/preferences.py

@@ -11,7 +11,9 @@ from classiq.interface.backend.quantum_backend_providers import (
     AllBackendsNameByVendor,
     ProviderVendor,
 )
-from classiq.interface.generator.arith.number_utils import MAXIMAL_MACHINE_PRECISION
+from classiq.interface.generator.arith.machine_precision import (
+    DEFAULT_MACHINE_PRECISION,
+)
 from classiq.interface.generator.hardware.hardware_data import (
     BACKEND_VALIDATION_ERROR_MESSAGE,
     CustomHardwareSettings,
@@ -78,7 +80,7 @@ class Preferences(pydantic.BaseModel, extra=pydantic.Extra.forbid):
     _backend_preferences: Optional[BackendPreferences] = pydantic.PrivateAttr(
         default=None
     )
-    machine_precision: PydanticMachinePrecision = MAXIMAL_MACHINE_PRECISION
+    machine_precision: PydanticMachinePrecision = DEFAULT_MACHINE_PRECISION
 
     backend_service_provider: Optional[Union[Provider, ProviderVendor, str]] = (
         pydantic.Field(

classiq/interface/generator/quantum_function_call.py

@@ -80,7 +80,7 @@ class WirePair(HashablePydanticBaseModel):
     out_wire: WireName
 
 
-SUFFIX_RANDOMIZER = random.Random()
+SUFFIX_RANDOMIZER = random.Random()  # noqa: S311
 
 
 def split_wire_pair_to_wires(

classiq/interface/generator/types/struct_declaration.py

@@ -2,15 +2,13 @@ from typing import Any, ClassVar, Dict, Mapping
 
 import pydantic
 
+from classiq.interface.ast_node import HashableASTNode
 from classiq.interface.generator.functions.classical_type import ConcreteClassicalType
-from classiq.interface.helpers.hashable_pydantic_base_model import (
-    HashablePydanticBaseModel,
-)
 
 from classiq.exceptions import ClassiqValueError
 
 
-class StructDeclaration(HashablePydanticBaseModel):
+class StructDeclaration(HashableASTNode):
     name: str
 
     variables: Dict[str, ConcreteClassicalType] = pydantic.Field(

classiq/interface/model/call_synthesis_data.py

@@ -1,5 +1,5 @@
 import dataclasses
-from typing import Any, List, Mapping
+from typing import Any, Iterator, List, Mapping
 
 from sympy import sympify
 
@@ -61,8 +61,8 @@ class CallSynthesisData(Mapping):
     def __getitem__(self, key: str) -> Any:
         return dataclasses.asdict(self)[key]
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[str]:
         return iter(dataclasses.asdict(self))
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(dataclasses.asdict(self))

classiq/interface/model/classical_if.py

@@ -0,0 +1,13 @@
+from typing import TYPE_CHECKING
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.quantum_statement import QuantumOperation
+
+if TYPE_CHECKING:
+    from classiq.interface.model.statement_block import StatementBlock
+
+
+class ClassicalIf(QuantumOperation):
+    condition: Expression
+    then: "StatementBlock"
+    else_: "StatementBlock"

classiq/interface/model/classical_parameter_declaration.py

@@ -1,8 +1,7 @@
-import pydantic
-
+from classiq.interface.ast_node import ASTNode
 from classiq.interface.generator.functions.classical_type import ConcreteClassicalType
 
 
-class ClassicalParameterDeclaration(pydantic.BaseModel):
+class ClassicalParameterDeclaration(ASTNode):
     name: str
     classical_type: ConcreteClassicalType

classiq/interface/model/{quantum_if_operation.py → control.py}

@@ -5,7 +5,10 @@ from sympy import Equality
 from sympy.core.numbers import Integer
 
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.qmod_qscalar_proxy import QmodQNumProxy
+from classiq.interface.generator.expressions.qmod_qscalar_proxy import (
+    QmodQNumProxy,
+    QmodSizedProxy,
+)
 from classiq.interface.model.quantum_expressions.control_state import (
     min_bit_length,
     to_twos_complement,
@@ -17,18 +20,18 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
 from classiq.exceptions import ClassiqValueError
 
 if TYPE_CHECKING:
-    from classiq.interface.model.quantum_lambda_function import QuantumOperand
+    from classiq.interface.model.statement_block import StatementBlock
 
-QUANTUM_IF_INOUT_NAME = "ctrl"
-QUANTUM_IF_CONDITION_ARG_ERROR_MESSAGE_FORMAT = (
-    "quantum_if condition must be of the form '<quantum-variable> == "
+CONTROL_INOUT_NAME = "ctrl"
+CONTROL_CTRL_ARG_ERROR_MESSAGE_FORMAT = (
+    "control condition must be of the form '<quantum-variable> == "
     "<classical-integer-expression>', but condition's {}-hand side was {!r}"
 )
 
 
-class QuantumIfOperation(QuantumExpressionOperation):
-    then: "QuantumOperand"
-    _ctrl: Optional[QmodQNumProxy] = pydantic.PrivateAttr(
+class Control(QuantumExpressionOperation):
+    body: "StatementBlock"
+    _ctrl: Optional[QmodSizedProxy] = pydantic.PrivateAttr(
         default=None,
     )
     _ctrl_val: Optional[int] = pydantic.PrivateAttr(
@@ -40,7 +43,7 @@ class QuantumIfOperation(QuantumExpressionOperation):
         return self.expression
 
     @property
-    def ctrl(self) -> QmodQNumProxy:
+    def ctrl(self) -> QmodSizedProxy:
         assert self._ctrl is not None
         return self._ctrl
 
@@ -51,44 +54,59 @@ class QuantumIfOperation(QuantumExpressionOperation):
 
     def resolve_condition(self) -> None:
         condition = self.condition.value.value
-        if not isinstance(condition, Equality):
+        if isinstance(condition, QmodSizedProxy):
+            self._resolve_port_condition(condition)
+        elif isinstance(condition, Equality):
+            self._resolve_num_condition(condition)
+        else:
             raise ClassiqValueError(
-                f"quantum_if condition must be an equality, was {str(condition)!r}"
+                f"control condition must be a qubit, an array of qubits, or a quantum "
+                f"numeric equality, was {str(condition)!r}"
             )
+
+    def _resolve_port_condition(self, condition: QmodSizedProxy) -> None:
+        self._ctrl = condition
+
+    def _resolve_num_condition(self, condition: Equality) -> None:
         ctrl, ctrl_val = condition.args
         if isinstance(ctrl, Integer) and isinstance(ctrl_val, QmodQNumProxy):
             ctrl, ctrl_val = ctrl_val, ctrl
         if not isinstance(ctrl, QmodQNumProxy):
             raise ClassiqValueError(
-                QUANTUM_IF_CONDITION_ARG_ERROR_MESSAGE_FORMAT.format("left", str(ctrl))
+                CONTROL_CTRL_ARG_ERROR_MESSAGE_FORMAT.format("left", str(ctrl))
             )
         if not isinstance(ctrl_val, Integer):
             raise ClassiqValueError(
-                QUANTUM_IF_CONDITION_ARG_ERROR_MESSAGE_FORMAT.format(
-                    "right", str(ctrl_val)
-                )
+                CONTROL_CTRL_ARG_ERROR_MESSAGE_FORMAT.format("right", str(ctrl_val))
             )
         self._ctrl, self._ctrl_val = ctrl, int(ctrl_val)
 
+    @property
+    def has_ctrl_state(self) -> bool:
+        assert self._ctrl is not None
+        return self._ctrl_val is not None
+
     @property
     def ctrl_state(self) -> str:
-        is_signed = self.ctrl.is_signed
-        fraction_places = self.ctrl.fraction_digits
-        ctrl_size = len(self.ctrl)
+        ctrl = self.ctrl
+        assert isinstance(ctrl, QmodQNumProxy)
+        is_signed = ctrl.is_signed
+        fraction_places = ctrl.fraction_digits
+        ctrl_size = len(ctrl)
         if not is_signed and self.ctrl_val < 0:
             raise ClassiqValueError(
-                f"Variable {str(self.ctrl)!r} is not signed but control value "
+                f"Variable {str(ctrl)!r} is not signed but control value "
                 f"{self.ctrl_val} is negative"
             )
         required_qubits = min_bit_length(self.ctrl_val, is_signed)
         if ctrl_size < required_qubits:
             raise ClassiqValueError(
-                f"Variable {str(self.ctrl)!r} has {ctrl_size} qubits but control value "
+                f"Variable {str(ctrl)!r} has {ctrl_size} qubits but control value "
                 f"{str(self.ctrl_val)!r} requires at least {required_qubits} qubits"
             )
         if fraction_places != 0:
             raise ClassiqValueError(
-                f"quantum-if on a non-integer quantum variable {str(self.ctrl)!r} is "
+                f"Comparison (`==`) on a non-integer quantum variable {str(ctrl)!r} is "
                 f"not supported at the moment"
             )
         return to_twos_complement(self.ctrl_val, ctrl_size, is_signed)

classiq/interface/model/handle_binding.py

@@ -1,9 +1,10 @@
-from pydantic import BaseModel, Extra
+from pydantic import Extra
 
+from classiq.interface.ast_node import ASTNode
 from classiq.interface.generator.expressions.expression import Expression
 
 
-class HandleBinding(BaseModel):
+class HandleBinding(ASTNode):
     name: str
 
     class Config:

classiq/interface/model/invert.py

@@ -0,0 +1,10 @@
+from typing import TYPE_CHECKING
+
+from classiq.interface.model.quantum_statement import QuantumOperation
+
+if TYPE_CHECKING:
+    from classiq.interface.model.statement_block import StatementBlock
+
+
+class Invert(QuantumOperation):
+    body: "StatementBlock"

classiq/interface/model/model.py

@@ -3,6 +3,7 @@ from typing import Any, Dict, List, Literal, NewType, Optional, Set
 
 import pydantic
 
+from classiq.interface.ast_node import ASTNode
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.functions.port_declaration import (
@@ -51,7 +52,7 @@ class VersionedSerializedModel(VersionedModel):
     model: SerializedModel
 
 
-class Model(VersionedModel):
+class Model(VersionedModel, ASTNode):
     """
     All the relevant data for generating quantum circuit in one place.
     """

classiq/interface/model/power.py

@@ -0,0 +1,12 @@
+from typing import TYPE_CHECKING
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.quantum_statement import QuantumOperation
+
+if TYPE_CHECKING:
+    from classiq.interface.model.statement_block import StatementBlock
+
+
+class Power(QuantumOperation):
+    power: Expression
+    body: "StatementBlock"

classiq/interface/model/quantum_function_call.py

@@ -1,10 +1,10 @@
 import itertools
 import re
-from typing import Any, Dict, List, Mapping, Optional, Set, Union
+from typing import Any, Dict, List, Mapping, Optional, Set, Type, Union
 
 import pydantic
-from pydantic import BaseModel
 
+from classiq.interface.ast_node import ASTNode
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.function_declaration import (
     FunctionDeclaration,
@@ -77,8 +77,13 @@ def _validate_no_duplicated_handles(
 def _validate_no_mixing_sliced_and_whole_handles(
     inouts: Mapping[str, HandleBinding],
 ) -> None:
+    def _treat_subscript_as_slice(type_: Type[HandleBinding]) -> Type[HandleBinding]:
+        if type_ == SubscriptHandleBinding:
+            return SlicedHandleBinding
+        return type_
+
     inout_handle_names_to_types = {
-        handle_name: {type(handle) for handle in handles}
+        handle_name: {_treat_subscript_as_slice(type(handle)) for handle in handles}
         for handle_name, handles in itertools.groupby(
             inouts.values(), lambda handle: handle.name
         )
@@ -103,7 +108,7 @@ ArgValue = Union[
 ]
 
 
-class OperandIdentifier(BaseModel):
+class OperandIdentifier(ASTNode):
     name: str
     index: Expression
 

classiq/interface/model/quantum_lambda_function.py

@@ -1,21 +1,18 @@
 from typing import TYPE_CHECKING, Dict, List, Optional, Union
 
 import pydantic
-from pydantic import BaseModel
 
+from classiq.interface.ast_node import ASTNode
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_function_declaration import (
     QuantumOperandDeclaration,
 )
-from classiq.interface.model.quantum_if_operation import QuantumIfOperation
 
 if TYPE_CHECKING:
     from classiq.interface.model.statement_block import StatementBlock
 
-from classiq.interface.model.within_apply_operation import WithinApplyOperation
 
-
-class QuantumLambdaFunction(BaseModel):
+class QuantumLambdaFunction(ASTNode):
     """
     The definition of an anonymous function passed as operand to higher-level functions
     """
@@ -39,7 +36,7 @@ class QuantumLambdaFunction(BaseModel):
         self._func_decl = fd
 
 
-class LambdaListComprehension(BaseModel):
+class LambdaListComprehension(ASTNode):
     """
     Specification of a list of lambda functions iteratively
     """
@@ -59,6 +56,3 @@ class LambdaListComprehension(BaseModel):
 
 QuantumCallable = Union[str, QuantumLambdaFunction]
 QuantumOperand = Union[QuantumCallable, List[QuantumCallable], LambdaListComprehension]
-
-QuantumIfOperation.update_forward_refs(QuantumOperand=QuantumOperand)
-WithinApplyOperation.update_forward_refs(QuantumOperand=QuantumOperand)

classiq/interface/model/quantum_statement.py

@@ -1,7 +1,8 @@
 from typing import Mapping, Union
 
-from pydantic import BaseModel, Extra
+from pydantic import Extra
 
+from classiq.interface.ast_node import ASTNode
 from classiq.interface.model.handle_binding import (
     HandleBinding,
     SlicedHandleBinding,
@@ -9,7 +10,7 @@ from classiq.interface.model.handle_binding import (
 )
 
 
-class QuantumStatement(BaseModel):
+class QuantumStatement(ASTNode):
     class Config:
         extra = Extra.forbid
 

classiq/interface/model/quantum_type.py

@@ -4,25 +4,24 @@ import pydantic
 from pydantic import Extra, Field
 from typing_extensions import Annotated
 
+from classiq.interface.ast_node import HashableASTNode
 from classiq.interface.generator.arith.register_user_input import (
     RegisterArithmeticInfo,
     RegisterUserInput,
 )
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.qmod_qarray_proxy import QmodQArrayProxy
 from classiq.interface.generator.expressions.qmod_qscalar_proxy import (
     QmodQNumProxy,
     QmodQScalarProxy,
 )
 from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
-from classiq.interface.helpers.hashable_pydantic_base_model import (
-    HashablePydanticBaseModel,
-)
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 
 from classiq.exceptions import ClassiqValueError
 
 
-class QuantumType(HashablePydanticBaseModel):
+class QuantumType(HashableASTNode):
     class Config:
         extra = Extra.forbid
 
@@ -67,12 +66,9 @@ class QuantumBit(QuantumScalar):
         return values_with_discriminator(values, "kind", "qbit")
 
 
-class QuantumArray(QuantumType):
-    length: Optional[Expression]
-
-
-class QuantumBitvector(QuantumArray):
+class QuantumBitvector(QuantumType):
     kind: Literal["qvec"]
+    length: Optional[Expression]
 
     @pydantic.root_validator(pre=True)
     def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
@@ -82,6 +78,9 @@ class QuantumBitvector(QuantumArray):
         if self.length is not None and self.length.is_evaluated():
             self._size_in_bits = self.length.to_int_value()
 
+    def get_proxy(self, name: str) -> QmodQArrayProxy:
+        return QmodQArrayProxy(name, self.size_in_bits)
+
 
 class QuantumNumeric(QuantumScalar):
     kind: Literal["qnum"]

classiq/interface/model/quantum_variable_declaration.py

@@ -1,8 +1,8 @@
 from typing import Any, Mapping, Optional
 
 import pydantic
-from pydantic import BaseModel
 
+from classiq.interface.ast_node import ASTNode
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_type import (
     ConcreteQuantumType,
@@ -11,7 +11,7 @@ from classiq.interface.model.quantum_type import (
 )
 
 
-class QuantumVariableDeclaration(BaseModel):
+class QuantumVariableDeclaration(ASTNode):
     name: str
     quantum_type: ConcreteQuantumType
     size: Optional[Expression] = pydantic.Field(default=None)