classiq 0.37.1__py3-none-any.whl → 0.65.3__py3-none-any.whl

classiq/interface/generator/functions/classical_type.py

@@ -1,43 +1,31 @@
-from abc import abstractmethod
-from typing import Any, Dict, List, Literal, Union
+from typing import TYPE_CHECKING, Any, Literal, Union
 
 import pydantic
-from pydantic import Extra, Field
+from pydantic import ConfigDict
 from sympy import IndexedBase, Symbol
-from typing_extensions import Annotated
 
-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.ast_node import HashableASTNode
 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
 
+if TYPE_CHECKING:
+    from classiq.interface.generator.functions.concrete_types import (
+        ConcreteClassicalType,
+    )
+
+CLASSICAL_ATTRIBUTES = {"len", "size", "is_signed", "fraction_digits"}
+
 NamedSymbol = Union[IndexedBase, Symbol]
 
 
-class ClassicalType(HashablePydanticBaseModel):
-    def as_symbolic(self, name: str) -> Union[NamedSymbol, List[NamedSymbol]]:
+class ClassicalType(HashableASTNode):
+    def as_symbolic(self, name: str) -> Union[NamedSymbol, list[NamedSymbol]]:
         return Symbol(name)
 
-    @property
-    @abstractmethod
-    def default_value(self) -> Any:
-        raise NotImplementedError(
-            f"{self.__class__.__name__} type has no default value"
-        )
+    model_config = ConfigDict(extra="forbid")
 
-    @property
-    def python_type(self) -> type:
-        raise NotImplementedError(
-            f"{self.__class__.__name__!r} has no Python SDK equivalent"
-        )
-
-    class Config:
-        extra = Extra.forbid
+    def __str__(self) -> str:
+        return str(type(self).__name__)
 
 
 class Integer(ClassicalType):
@@ -46,18 +34,11 @@ class Integer(ClassicalType):
     def as_symbolic(self, name: str) -> Symbol:
         return Symbol(name, integer=True)
 
-    @property
-    def default_value(self) -> int:
-        return 0
-
-    @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")
 
-    @property
-    def python_type(self) -> type:
-        return int
-
 
 class Real(ClassicalType):
     kind: Literal["real"]
@@ -65,34 +46,20 @@ class Real(ClassicalType):
     def as_symbolic(self, name: str) -> Symbol:
         return Symbol(name, real=True)
 
-    @property
-    def default_value(self) -> float:
-        return 0
-
-    @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")
 
-    @property
-    def python_type(self) -> type:
-        return float
-
 
 class Bool(ClassicalType):
     kind: Literal["bool"]
 
-    @property
-    def default_value(self) -> bool:
-        return 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", "bool")
 
-    @property
-    def python_type(self) -> type:
-        return bool
-
 
 class ClassicalList(ClassicalType):
     kind: Literal["list"]
@@ -101,68 +68,21 @@ class ClassicalList(ClassicalType):
     def as_symbolic(self, name: str) -> Symbol:
         return IndexedBase(name)
 
-    @property
-    def default_value(self) -> List:
-        return []
-
-    @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")
 
-    @property
-    def python_type(self) -> type:
-        return List[self.element_type.python_type]  # type:ignore[name-defined]
-
-
-class Pauli(ClassicalType):
-    kind: Literal["pauli"]
-
-    @property
-    def default_value(self) -> PauliEnum:
-        return PauliEnum.I
-
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        return values_with_discriminator(values, "kind", "pauli")
-
-    @property
-    def python_type(self) -> type:
-        return int
-
 
 class StructMetaType(ClassicalType):
     kind: Literal["type_proxy"]
 
-    @property
-    def default_value(self) -> Any:
-        return super().default_value
-
-    @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")
 
 
-class QStructBase:  # marker for Qmod structs in the Python SDK
-    pass
-
-
-class Struct(ClassicalType):
-    kind: Literal["struct_instance"]
-    name: str = pydantic.Field(description="The struct type of the instance")
-
-    @property
-    def default_value(self) -> Any:
-        return super().default_value
-
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        return values_with_discriminator(values, "kind", "struct_instance")
-
-    @property
-    def python_type(self) -> type:
-        return type(self.name, (QStructBase,), dict())
-
-
 class ClassicalArray(ClassicalType):
     kind: Literal["array"]
     element_type: "ConcreteClassicalType"
@@ -171,92 +91,53 @@ 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)]
 
-    @property
-    def default_value(self) -> Any:
-        return super().default_value
-
-    @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")
 
 
 class OpaqueHandle(ClassicalType):
-    @property
-    def default_value(self) -> int:
-        return 0
+    pass
 
 
 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")
 
 
-class LadderOperator(ClassicalType):
-    kind: Literal["ladder_operator"]
-
-    @property
-    def default_value(self) -> LadderOperatorEnum:
-        return LadderOperatorEnum.PLUS
-
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        return values_with_discriminator(values, "kind", "ladder_operator")
-
-    @property
-    def python_type(self) -> type:
-        return int
-
-
-ConcreteClassicalType = Annotated[
-    Union[
-        Integer,
-        Real,
-        Bool,
-        ClassicalList,
-        Pauli,
-        StructMetaType,
-        Struct,
-        ClassicalArray,
-        VQEResult,
-        Histogram,
-        Estimation,
-        LadderOperator,
-        IQAERes,
-    ],
-    Field(discriminator="kind"),
-]
-ClassicalList.update_forward_refs()
-ClassicalArray.update_forward_refs()
-
-
-def as_symbolic(symbols: Dict[str, ClassicalType]) -> Dict[str, RuntimeExpression]:
+def as_symbolic(symbols: dict[str, ClassicalType]) -> dict[str, RuntimeExpression]:
     return {
         param_name: param_type.as_symbolic(param_name)
         for param_name, param_type in symbols.items()

classiq/interface/generator/functions/concrete_types.py

@@ -0,0 +1,55 @@
+from typing import Annotated, Union
+
+from pydantic import Field
+
+from classiq.interface.generator.functions.classical_type import (
+    Bool,
+    ClassicalArray,
+    ClassicalList,
+    Estimation,
+    Histogram,
+    Integer,
+    IQAERes,
+    Real,
+    StructMetaType,
+    VQEResult,
+)
+from classiq.interface.generator.functions.type_name import Enum, TypeName
+from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
+from classiq.interface.model.quantum_type import (
+    QuantumBit,
+    QuantumBitvector,
+    QuantumNumeric,
+    RegisterQuantumType,
+)
+
+ConcreteClassicalType = Annotated[
+    Union[
+        Integer,
+        Real,
+        Bool,
+        ClassicalList,
+        StructMetaType,
+        TypeName,
+        ClassicalArray,
+        VQEResult,
+        Histogram,
+        Estimation,
+        IQAERes,
+    ],
+    Field(discriminator="kind"),
+]
+ClassicalList.model_rebuild()
+ClassicalArray.model_rebuild()
+
+NativePythonClassicalTypes = (int, float, bool, list)
+PythonClassicalPydanticTypes = (Enum,)
+
+ConcreteQuantumType = Annotated[
+    Union[QuantumBit, QuantumBitvector, QuantumNumeric, TypeName],
+    Field(discriminator="kind", default_factory=QuantumBitvector),
+]
+QuantumBitvector.model_rebuild()
+TypeName.model_rebuild()
+QStructDeclaration.model_rebuild()
+RegisterQuantumType.model_rebuild()

classiq/interface/generator/functions/function_declaration.py

@@ -1,26 +1,25 @@
 import abc
-from typing import Dict
+from collections.abc import Sequence
 
-import pydantic
-from pydantic.main import BaseModel
+from pydantic import ConfigDict
 
-from classiq.interface.generator.functions.classical_type import ConcreteClassicalType
+from classiq.interface.model.classical_parameter_declaration import (
+    AnonClassicalParameterDeclaration,
+)
+from classiq.interface.model.parameter import Parameter
 
 
-class FunctionDeclaration(BaseModel, abc.ABC):
+class FunctionDeclaration(Parameter, abc.ABC):
     """
     Facilitates the creation of a common function interface object.
     """
 
-    name: str = pydantic.Field(description="The name of the function")
+    @property
+    @abc.abstractmethod
+    def param_decls(self) -> Sequence["AnonClassicalParameterDeclaration"]:
+        pass
 
-    param_decls: Dict[str, ConcreteClassicalType] = pydantic.Field(
-        description="The expected interface of the functions parameters",
-        default_factory=dict,
-    )
+    model_config = ConfigDict(extra="forbid")
 
-    class Config:
-        extra = pydantic.Extra.forbid
 
-
-FunctionDeclaration.update_forward_refs()
+FunctionDeclaration.model_rebuild()

classiq/interface/generator/functions/port_declaration.py

@@ -1,12 +1,8 @@
 from typing import Any
 
-import pydantic
-from pydantic import BaseModel
-
+from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.function_params import PortDirection
 
-from classiq._internals.enum_utils import StrEnum
-
 
 class PortDeclarationDirection(StrEnum):
     Input = "input"
@@ -39,11 +35,3 @@ class PortDeclarationDirection(StrEnum):
         cls, port_direction: PortDirection
     ) -> "PortDeclarationDirection":
         return cls(port_direction.value)
-
-
-class SynthesisPortDeclaration(BaseModel):
-    name: str
-    size: int
-    direction: PortDeclarationDirection
-    is_signed: bool = pydantic.Field(default=False)
-    fraction_places: int = pydantic.Field(default=0)

classiq/interface/generator/functions/qmod_python_interface.py

@@ -1,3 +1,4 @@
-from typing import Any, Mapping
+from collections.abc import Mapping
+from typing import Any
 
 QmodPyStruct = Mapping[str, Any]

classiq/interface/generator/functions/type_name.py

@@ -0,0 +1,90 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Literal, Optional
+
+import pydantic
+
+from classiq.interface.exceptions import ClassiqInternalError
+from classiq.interface.generator.expressions.qmod_qstruct_proxy import QmodQStructProxy
+from classiq.interface.generator.functions.classical_type import (
+    ClassicalType,
+)
+from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.quantum_type import (
+    QuantumType,
+)
+
+if TYPE_CHECKING:
+    from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
+
+
+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.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:
+        fields_types = list(self.fields.values())
+        for field_type in fields_types:
+            field_type._update_size_in_bits_from_declaration()
+        if all(field_type.has_size_in_bits for field_type in fields_types):
+            self._size_in_bits = sum(
+                field_type.size_in_bits for field_type in fields_types
+            )
+
+    def get_proxy(self, handle: "HandleBinding") -> "QmodQStructProxy":
+        from classiq.interface.generator.expressions.qmod_qstruct_proxy import (
+            QmodQStructProxy,
+        )
+
+        return QmodQStructProxy(
+            handle=handle, struct_name=self.name, fields=self.fields
+        )
+
+    @property
+    def qmod_type_name(self) -> str:
+        return self.name
+
+    @property
+    def type_name(self) -> str:
+        return self.name
+
+    @property
+    def fields(self) -> Mapping[str, "ConcreteQuantumType"]:
+        if self._assigned_fields is None:
+            raise ClassiqInternalError("Fields not set")
+        return self._assigned_fields
+
+    @property
+    def has_fields(self) -> bool:
+        return self._assigned_fields is not None
+
+    def set_fields(self, fields: Mapping[str, "ConcreteQuantumType"]) -> None:
+        self._assigned_fields = fields
+
+    @property
+    def is_instantiated(self) -> bool:
+        return self.has_fields and all(
+            field_type.is_instantiated for field_type in self.fields.values()
+        )
+
+    @property
+    def is_evaluated(self) -> bool:
+        return self.has_fields and all(
+            field_type.is_evaluated for field_type in self.fields.values()
+        )
+
+
+class Enum(TypeName):
+    pass
+
+
+class Struct(TypeName):
+    pass