classiq 0.43.3__py3-none-any.whl → 0.45.0__py3-none-any.whl

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

@@ -1,35 +1,22 @@
-from typing import Any
-
 from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
+    NamedParamsQuantumFunctionDeclaration,
     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(
+PERMUTE_OPERATOR = NamedParamsQuantumFunctionDeclaration(
     name="permute",
-    operand_declarations={
-        "functions": QuantumOperandDeclaration(
+    positional_arg_declarations=[
+        QuantumOperandDeclaration(
             name="functions",
             is_list=True,
         )
-    },
+    ],
 )
 
-APPLY_OPERATOR = get_single_empty_operand_operator(operator_name="apply")
+APPLY_OPERATOR = NamedParamsQuantumFunctionDeclaration(
+    name="apply",
+    positional_arg_declarations=[QuantumOperandDeclaration(name="operand")],
+)
 
 STD_QMOD_OPERATORS = [
     PERMUTE_OPERATOR,

classiq/interface/generator/functions/classical_function_declaration.py

@@ -1,11 +1,14 @@
-from typing import ClassVar, Dict, Mapping, Optional
+from typing import ClassVar, Dict, Optional, Sequence
 
 import pydantic
 
-from classiq.interface.generator.functions.classical_type import ConcreteClassicalType
+from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 from classiq.interface.generator.functions.function_declaration import (
     FunctionDeclaration,
 )
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 
 
 class ClassicalFunctionDeclaration(FunctionDeclaration):
@@ -13,6 +16,12 @@ class ClassicalFunctionDeclaration(FunctionDeclaration):
     Facilitates the creation of a common classical function interface object.
     """
 
+    name: str
+
+    positional_parameters: Sequence[ClassicalParameterDeclaration] = pydantic.Field(
+        default_factory=list,
+    )
+
     return_type: Optional[ConcreteClassicalType] = pydantic.Field(
         description="The type of the classical value that is returned by the function (for classical functions)",
         default=None,
@@ -26,10 +35,9 @@ class ClassicalFunctionDeclaration(FunctionDeclaration):
         Dict[str, "ClassicalFunctionDeclaration"]
     ] = {}
 
-    def update_logic_flow(
-        self, function_dict: Mapping[str, "ClassicalFunctionDeclaration"]
-    ) -> None:
-        pass
+    @property
+    def param_decls(self) -> Sequence[ClassicalParameterDeclaration]:
+        return self.positional_parameters
 
 
 ClassicalFunctionDeclaration.update_forward_refs()

classiq/interface/generator/functions/classical_type.py

@@ -1,14 +1,18 @@
-from typing import Any, Dict, List, Literal, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Literal, Union
 
 import pydantic
-from pydantic import Extra, Field
+from pydantic import Extra
 from sympy import IndexedBase, Symbol
-from typing_extensions import Annotated
 
 from classiq.interface.ast_node import HashableASTNode
 from classiq.interface.generator.expressions.expression_types import RuntimeExpression
 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]
@@ -18,12 +22,6 @@ class ClassicalType(HashableASTNode):
     def as_symbolic(self, name: str) -> Union[NamedSymbol, List[NamedSymbol]]:
         return Symbol(name)
 
-    @property
-    def qmod_type(self) -> type:
-        raise NotImplementedError(
-            f"{self.__class__.__name__!r} has no QMOD SDK equivalent"
-        )
-
     class Config:
         extra = Extra.forbid
 
@@ -41,12 +39,6 @@ class Integer(ClassicalType):
     def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         return values_with_discriminator(values, "kind", "int")
 
-    @property
-    def qmod_type(self) -> type:
-        from classiq.qmod.qmod_parameter import CInt
-
-        return CInt
-
 
 class Real(ClassicalType):
     kind: Literal["real"]
@@ -58,12 +50,6 @@ class Real(ClassicalType):
     def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         return values_with_discriminator(values, "kind", "real")
 
-    @property
-    def qmod_type(self) -> type:
-        from classiq.qmod.qmod_parameter import CReal
-
-        return CReal
-
 
 class Bool(ClassicalType):
     kind: Literal["bool"]
@@ -72,12 +58,6 @@ class Bool(ClassicalType):
     def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         return values_with_discriminator(values, "kind", "bool")
 
-    @property
-    def qmod_type(self) -> type:
-        from classiq.qmod.qmod_parameter import CBool
-
-        return CBool
-
 
 class ClassicalList(ClassicalType):
     kind: Literal["list"]
@@ -90,26 +70,6 @@ class ClassicalList(ClassicalType):
     def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         return values_with_discriminator(values, "kind", "list")
 
-    @property
-    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):
-    kind: Literal["pauli"]
-
-    @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 qmod_type(self) -> type:
-        from classiq.qmod.builtins.enums import Pauli
-
-        return Pauli
-
 
 class StructMetaType(ClassicalType):
     kind: Literal["type_proxy"]
@@ -119,27 +79,6 @@ class StructMetaType(ClassicalType):
         return values_with_discriminator(values, "kind", "type_proxy")
 
 
-class TypeName(ClassicalType):
-    kind: Literal["struct_instance"]
-    name: str = pydantic.Field(description="The type name of the instance")
-
-    @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 qmod_type(self) -> type:
-        return type(self.name, (TypeName,), dict())
-
-
-class Enum(TypeName):
-    pass
-
-
-class Struct(TypeName):
-    pass
-
-
 class ClassicalArray(ClassicalType):
     kind: Literal["array"]
     element_type: "ConcreteClassicalType"
@@ -152,14 +91,6 @@ class ClassicalArray(ClassicalType):
     def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         return values_with_discriminator(values, "kind", "array")
 
-    @property
-    def qmod_type(self) -> type:
-        from classiq.qmod.qmod_parameter import CArray
-
-        return CArray[
-            self.element_type.qmod_type, self.size  # type:ignore[name-defined]
-        ]
-
 
 class OpaqueHandle(ClassicalType):
     pass
@@ -197,44 +128,6 @@ class IQAERes(OpaqueHandle):
         return values_with_discriminator(values, "kind", "iqae_result")
 
 
-class LadderOperator(ClassicalType):
-    kind: Literal["ladder_operator"]
-
-    @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 qmod_type(self) -> type:
-        from classiq.qmod.builtins.enums import LadderOperator
-
-        return LadderOperator
-
-
-ConcreteClassicalType = Annotated[
-    Union[
-        Integer,
-        Real,
-        Bool,
-        ClassicalList,
-        Pauli,
-        StructMetaType,
-        TypeName,
-        ClassicalArray,
-        VQEResult,
-        Histogram,
-        Estimation,
-        LadderOperator,
-        IQAERes,
-    ],
-    Field(discriminator="kind"),
-]
-ClassicalList.update_forward_refs()
-ClassicalArray.update_forward_refs()
-
-PythonClassicalTypes = (int, float, bool, list, Enum)
-
-
 def as_symbolic(symbols: Dict[str, ClassicalType]) -> Dict[str, RuntimeExpression]:
     return {
         param_name: param_type.as_symbolic(param_name)

classiq/interface/generator/functions/concrete_types.py

@@ -0,0 +1,55 @@
+from typing import Union
+
+from pydantic import Field
+from typing_extensions import Annotated
+
+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.update_forward_refs(ConcreteClassicalType=ConcreteClassicalType)
+ClassicalArray.update_forward_refs(ConcreteClassicalType=ConcreteClassicalType)
+
+PythonClassicalTypes = (int, float, bool, list, 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)

classiq/interface/generator/functions/function_declaration.py

@@ -1,23 +1,23 @@
 import abc
-from typing import Dict
+from typing import Sequence
 
 import pydantic
 
-from classiq.interface.ast_node import ASTNode
-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(ASTNode, 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")
-
-    param_decls: Dict[str, ConcreteClassicalType] = pydantic.Field(
-        description="The expected interface of the functions parameters",
-        default_factory=dict,
-    )
+    @property
+    @abc.abstractmethod
+    def param_decls(self) -> Sequence[AnonClassicalParameterDeclaration]:
+        pass
 
     class Config:
         extra = pydantic.Extra.forbid

classiq/interface/generator/functions/port_declaration.py

@@ -1,9 +1,8 @@
 from typing import Any
 
+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"

classiq/interface/generator/functions/type_name.py

@@ -0,0 +1,80 @@
+from typing import TYPE_CHECKING, Any, Dict, Literal, Mapping, Optional
+
+import pydantic
+
+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):  # type:ignore[misc]
+    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]:
+        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"]:
+        from classiq.qmod.model_state_container import QMODULE
+
+        if self._assigned_fields is None:
+            qstruct_fields = QMODULE.qstruct_decls[self.name].fields
+            self._assigned_fields = {
+                field_name: field_type.copy()
+                for field_name, field_type in qstruct_fields.items()
+            }
+
+        return self._assigned_fields
+
+    def _set_fields(self, fields: Mapping[str, "ConcreteQuantumType"]) -> None:
+        from classiq.qmod.model_state_container import QMODULE
+
+        QMODULE.qstruct_decls[self.name].fields = fields
+
+
+class Enum(TypeName):
+    pass
+
+
+class Struct(TypeName):
+    pass

classiq/interface/generator/generated_circuit_data.py

@@ -21,7 +21,7 @@ VISUALIZATION_HIDE_LIST = [
     "control",
     "mcx",
     "iteration",
-    "operand",
+    "stmt_block",
 ]
 
 
@@ -94,9 +94,9 @@ class GeneratedCircuitData(pydantic.BaseModel):
         return cls(width=0)
 
 
-class FunctionDebugInfo(pydantic.BaseModel):
+class FunctionDebugInfoInterface(pydantic.BaseModel):
     generated_function: Optional[GeneratedFunction]
-    children: List["FunctionDebugInfo"]
+    children: List["FunctionDebugInfoInterface"]
     relative_qubits: Tuple[int, ...]
     absolute_qubits: Optional[Tuple[int, ...]]
     is_basis_gate: Optional[bool]

classiq/interface/generator/grover_diffuser.py

@@ -2,6 +2,7 @@ from typing import Any, Dict, List, Set, Tuple, Union
 
 import pydantic
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.function_params import (
     ArithmeticIODict,
@@ -11,8 +12,6 @@ from classiq.interface.generator.function_params import (
 from classiq.interface.generator.state_preparation import StatePreparation
 from classiq.interface.generator.user_defined_function_params import CustomFunction
 
-from classiq.exceptions import ClassiqValueError
-
 GroverStatePreparation = Union[StatePreparation, CustomFunction]
 
 

classiq/interface/generator/grover_operator.py

@@ -2,6 +2,7 @@ from typing import Any, Dict, Optional
 
 import pydantic
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.function_params import (
     FunctionParams,
     FunctionParamsDiscriminator,
@@ -18,8 +19,6 @@ from classiq.interface.generator.oracles.oracle_function_param_list import (
 from classiq.interface.generator.range_types import NonNegativeFloatRange
 from classiq.interface.generator.state_preparation import Metrics, StatePreparation
 
-from classiq.exceptions import ClassiqValueError
-
 _DEFAULT_ORACLE_DISCRIMINATOR: FunctionParamsDiscriminator = (
     ArithmeticOracle.discriminator()
 )

classiq/interface/generator/hamiltonian_evolution/exponentiation.py

@@ -4,12 +4,11 @@ import pydantic
 
 from classiq.interface.chemistry import operator
 from classiq.interface.chemistry.operator import PauliOperator
+from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.hamiltonian_evolution.hamiltonian_evolution import (
     HamiltonianEvolution,
 )
 
-from classiq._internals.enum_utils import StrEnum
-
 
 class ExponentiationOptimization(StrEnum):
     MINIMIZE_DEPTH = "MINIMIZE_DEPTH"

classiq/interface/generator/hamiltonian_evolution/suzuki_trotter.py

@@ -2,13 +2,12 @@ import pydantic
 
 from classiq.interface.chemistry import operator
 from classiq.interface.chemistry.operator import PauliOperator
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.hamiltonian_evolution.hamiltonian_evolution import (
     HamiltonianEvolution,
 )
 from classiq.interface.generator.parameters import ParameterFloatType
 
-from classiq.exceptions import ClassiqValueError
-
 
 class SuzukiParameters(pydantic.BaseModel):
     order: pydantic.PositiveInt = pydantic.Field(

classiq/interface/generator/hardware/hardware_data.py

@@ -5,6 +5,7 @@ from typing import Any, Dict, List, MutableSet, Optional
 import pydantic
 
 from classiq.interface.backend.backend_preferences import BackendPreferences
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.transpiler_basis_gates import (
     DEFAULT_BASIS_GATES,
     DEFAULT_ROUTING_BASIS_GATES,
@@ -14,8 +15,6 @@ from classiq.interface.generator.transpiler_basis_gates import (
 )
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonNegIntTuple
 
-from classiq.exceptions import ClassiqValueError
-
 ConnectivityMap = List[PydanticNonNegIntTuple]
 BACKEND_VALIDATION_ERROR_MESSAGE = (
     "Backend service provider and backend name should be specified together."

classiq/interface/generator/hardware_efficient_ansatz.py

@@ -3,6 +3,8 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
 import pydantic
 
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator import function_params
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.function_params import (
@@ -15,9 +17,6 @@ from classiq.interface.generator.transpiler_basis_gates import (
 )
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonNegIntTuple
 
-from classiq._internals.enum_utils import StrEnum
-from classiq.exceptions import ClassiqValueError
-
 ConnectivityMap = List[PydanticNonNegIntTuple]
 
 

classiq/interface/generator/hartree_fock.py

@@ -7,12 +7,11 @@ from classiq.interface.chemistry.ground_state_problem import (
     HamiltonianProblem,
     MoleculeProblem,
 )
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.chemistry_function_params import (
     ChemistryFunctionParams,
 )
 
-from classiq.exceptions import ClassiqValueError
-
 
 class HartreeFock(ChemistryFunctionParams):
     @pydantic.validator("gs_problem")

classiq/interface/generator/linear_pauli_rotations.py

@@ -2,11 +2,10 @@ from typing import TYPE_CHECKING, Any, Dict, List
 
 import pydantic
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator import function_params
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 
-from classiq.exceptions import ClassiqValueError
-
 STATE = "state"
 TARGET = "target"
 

classiq/interface/generator/mcmt_method.py

@@ -1,4 +1,4 @@
-from classiq._internals.enum_utils import StrEnum
+from classiq.interface.enum_utils import StrEnum
 
 
 class McmtMethod(StrEnum):

classiq/interface/generator/mcu.py

@@ -2,13 +2,12 @@ from typing import Any, Dict, Optional, cast
 
 import pydantic
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.control_state import ControlState
 from classiq.interface.generator.function_params import FunctionParams
 from classiq.interface.generator.parameters import ParameterFloatType
 
-from classiq.exceptions import ClassiqValueError
-
 CTRL = "CTRL"
 TARGET = "TARGET"
 

classiq/interface/generator/mcx.py

@@ -2,12 +2,11 @@ from typing import Any, Dict, List, Optional
 
 import pydantic
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.control_state import ControlState
 from classiq.interface.generator.function_params import FunctionParams
 
-from classiq.exceptions import ClassiqValueError
-
 CTRL = "CTRL_IN"
 TARGET_QUBIT = "TARGET_QUBIT"
 

classiq/interface/generator/model/constraints.py

@@ -4,11 +4,10 @@ from typing import Dict, Optional, Union
 import pydantic
 from pydantic import BaseModel, Extra
 
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.transpiler_basis_gates import TranspilerBasisGates
 
-from classiq._internals.enum_utils import StrEnum
-from classiq.exceptions import ClassiqValueError
-
 UNCONSTRAINED = -1