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

classiq/interface/model/model.py

@@ -1,8 +1,12 @@
 from collections import Counter
-from typing import Any, Dict, List, Literal, NewType, Optional, Set
+from collections.abc import Mapping
+from typing import Any, Literal, NewType
 
 import pydantic
 
+from classiq.interface.ast_node import ASTNode
+from classiq.interface.debug_info.debug_info import DebugInfoCollection
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.functions.port_declaration import (
@@ -11,20 +15,20 @@ from classiq.interface.generator.functions.port_declaration import (
 from classiq.interface.generator.model.constraints import Constraints
 from classiq.interface.generator.model.preferences.preferences import Preferences
 from classiq.interface.generator.quantum_function_call import SUFFIX_RANDOMIZER
+from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
+from classiq.interface.generator.types.enum_declaration import EnumDeclaration
+from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.helpers.versioned_model import VersionedModel
-from classiq.interface.model.native_function_definition import NativeFunctionDefinition
-from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
+from classiq.interface.model.native_function_definition import (
+    NativeFunctionDefinition,
 )
-from classiq.interface.model.resolvers.function_call_resolver import (
-    resolve_function_calls,
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
 )
 from classiq.interface.model.statement_block import StatementBlock
 
-from classiq.exceptions import ClassiqValueError
-
 USER_MODEL_MARKER = "user"
 
 MAIN_FUNCTION_NAME = "main"
@@ -51,29 +55,37 @@ class VersionedSerializedModel(VersionedModel):
     model: SerializedModel
 
 
-class Model(VersionedModel):
-    """
-    All the relevant data for generating quantum circuit in one place.
-    """
+class Model(VersionedModel, ASTNode):
 
     kind: Literal["user"] = pydantic.Field(default=USER_MODEL_MARKER)
 
     # Must be validated before logic_flow
-    functions: List[NativeFunctionDefinition] = pydantic.Field(
+    functions: list[NativeFunctionDefinition] = pydantic.Field(
         default_factory=list,
         description="The user-defined custom type library.",
+        validate_default=True,
+    )
+
+    enums: list[EnumDeclaration] = pydantic.Field(
+        default_factory=list,
+        description="user-defined enums",
     )
 
-    types: List[StructDeclaration] = pydantic.Field(
+    types: list[StructDeclaration] = pydantic.Field(
         default_factory=list,
-        description="The user-defined custom function library.",
+        description="user-defined structs",
+    )
+
+    qstructs: list[QStructDeclaration] = pydantic.Field(
+        default_factory=list,
+        description="user-defined quantum structs",
     )
 
     classical_execution_code: str = pydantic.Field(
         description="The classical execution code of the model", default=""
     )
 
-    constants: List[Constant] = pydantic.Field(
+    constants: list[Constant] = pydantic.Field(
         default_factory=list,
     )
 
@@ -84,6 +96,13 @@ class Model(VersionedModel):
     )
     preferences: Preferences = pydantic.Field(default_factory=Preferences)
 
+    debug_info: DebugInfoCollection = pydantic.Field(
+        default_factory=DebugInfoCollection
+    )
+    functions_compilation_metadata: dict[str, CompilationMetadata] = pydantic.Field(
+        default_factory=dict
+    )
+
     @property
     def main_func(self) -> NativeFunctionDefinition:
         return self.function_dict[MAIN_FUNCTION_NAME]  # type:ignore[return-value]
@@ -92,9 +111,17 @@ class Model(VersionedModel):
     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(
@@ -105,69 +132,41 @@ class Model(VersionedModel):
         return direction
 
     @property
-    def function_dict(self) -> Dict[str, QuantumFunctionDeclaration]:
+    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]:
+        cls, functions: list[NativeFunctionDefinition]
+    ) -> list[NativeFunctionDefinition]:
         function_dict = nameables_to_dict(functions)
         if MAIN_FUNCTION_NAME not in function_dict:
             functions.append(_create_empty_main_function())
         return functions
 
-    @pydantic.root_validator()
-    def validate_static_correctness(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        functions: Optional[List[QuantumFunctionDeclaration]] = values.get("functions")
-        if functions is None:
-            return values
-
-        resolve_function_calls(
-            values,
-            nameables_to_dict(functions),
-        )
-        for func_def in functions:
-            if isinstance(func_def, NativeFunctionDefinition):
-                func_def.validate_body()
-        return values
-
-    @pydantic.validator("types")
-    def types_validator(cls, types: List[StructDeclaration]) -> List[StructDeclaration]:
-        user_defined_types: Set[str] = set()
-        for ctype in types:
-            if ctype.name in StructDeclaration.BUILTIN_STRUCT_DECLARATIONS:
-                raise ClassiqValueError(
-                    TYPE_NAME_CONFLICT_BUILTIN.format(name=ctype.name)
-                )
-            if ctype.name in user_defined_types:
-                raise ClassiqValueError(TYPE_NAME_CONFLICT_USER.format(name=ctype.name))
-            user_defined_types.add(ctype.name)
-
-        return types
-
     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]:
+        cls, functions: list[NativeFunctionDefinition]
+    ) -> list[NativeFunctionDefinition]:
         function_dict = nameables_to_dict(functions)
         if MAIN_FUNCTION_NAME not in function_dict:
             raise ClassiqValueError("The model must contain a `main` function")
         if any(
             pd.direction != PortDeclarationDirection.Output
-            for pd in function_dict[MAIN_FUNCTION_NAME].port_declarations.values()
+            for pd in function_dict[MAIN_FUNCTION_NAME].port_declarations
         ):
             raise ClassiqValueError("Function 'main' cannot declare quantum inputs")
 
         return functions
 
-    @pydantic.validator("constants")
-    def _validate_constants(cls, constants: List[Constant]) -> List[Constant]:
+    @pydantic.field_validator("constants")
+    @classmethod
+    def _validate_constants(cls, constants: list[Constant]) -> list[Constant]:
         constant_definition_counts = Counter(
             [constant.name for constant in constants]
         ).items()
@@ -180,3 +179,12 @@ class Model(VersionedModel):
                 f"{multiply_defined_constants}"
             )
         return constants
+
+    def dump_no_preferences_and_constraints(self) -> dict[str, Any]:
+        return self.model_dump(
+            exclude={
+                "constraints",
+                "execution_preferences",
+                "preferences",
+            },
+        )

classiq/interface/model/native_function_definition.py

@@ -1,18 +1,23 @@
+from typing import TYPE_CHECKING
+
 import pydantic
 
 from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
-)
-from classiq.interface.model.statement_block import StatementBlock
-from classiq.interface.model.validations.handles_validator import HandleValidator
-from classiq.interface.model.variable_declaration_statement import (
-    VariableDeclarationStatement,
+    NamedParamsQuantumFunctionDeclaration,
 )
 
-from classiq.exceptions import ClassiqValueError
+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(QuantumFunctionDeclaration):
+class NativeFunctionDefinition(NamedParamsQuantumFunctionDeclaration):
     """
     Facilitates the creation of a user-defined composite function
 
@@ -20,17 +25,9 @@ class NativeFunctionDefinition(QuantumFunctionDeclaration):
     objects from other classes.
     """
 
-    body: StatementBlock = pydantic.Field(
+    body: "StatementBlock" = pydantic.Field(
         default_factory=list, description="List of function calls to perform."
     )
-
-    def validate_body(self) -> None:
-        handle_validator = HandleValidator(self.port_declarations)
-
-        for statement in self.body:
-            if isinstance(statement, VariableDeclarationStatement):
-                handle_validator.handle_variable_declaration(statement)
-            else:
-                handle_validator.handle_operation(statement)
-
-        handle_validator.report_errored_handles(ClassiqValueError)
+    synthesis_data: FunctionSynthesisData = pydantic.Field(
+        default_factory=FunctionSynthesisData, deprecated=True, exclude=True
+    )

classiq/interface/model/parameter.py

@@ -0,0 +1,13 @@
+from typing import Optional
+
+from classiq.interface.ast_node import ASTNode
+from classiq.interface.exceptions import ClassiqError
+
+
+class Parameter(ASTNode):
+    name: Optional[str]
+
+    def get_name(self) -> str:
+        if self.name is None:
+            raise ClassiqError("Cannot resolve parameter name")
+        return self.name

classiq/interface/model/phase_operation.py

@@ -0,0 +1,11 @@
+from typing import Literal
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumExpressionOperation,
+)
+
+
+class PhaseOperation(QuantumExpressionOperation):
+    kind: Literal["PhaseOperation"]
+    theta: Expression

classiq/interface/model/port_declaration.py

@@ -1,27 +1,45 @@
-from typing import Any, Mapping
+from typing import Any, 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
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.model.quantum_variable_declaration import (
-    QuantumVariableDeclaration,
-)
-
-from classiq.exceptions import ClassiqValueError
+from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
+from classiq.interface.model.parameter import Parameter
 
 
-class PortDeclaration(QuantumVariableDeclaration):
+class AnonPortDeclaration(Parameter):
+    quantum_type: ConcreteQuantumType
     direction: PortDeclarationDirection
+    kind: Literal["PortDeclaration"]
+
+    @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:
                 raise ClassiqValueError("Port declaration is missing a type")
 
         return direction
+
+    def rename(self, new_name: str) -> "PortDeclaration":
+        if type(self) not in (AnonPortDeclaration, PortDeclaration):
+            raise ClassiqInternalError
+        return PortDeclaration(**{**self.__dict__, "name": new_name})
+
+
+class PortDeclaration(AnonPortDeclaration):
+    name: str

classiq/interface/model/power.py

@@ -0,0 +1,14 @@
+from typing import TYPE_CHECKING, Literal
+
+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):
+    kind: Literal["Power"]
+
+    power: Expression
+    body: "StatementBlock"

classiq/interface/model/quantum_expressions/amplitude_loading_operation.py

@@ -1,63 +1,75 @@
-from typing import Dict, Mapping, Union
+from collections.abc import Mapping, Sequence
+from typing import Literal
 
 import pydantic
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.amplitude_loading import (
     AMPLITUDE_IO_NAME,
     TARGET_OUTPUT_NAME,
 )
 from classiq.interface.model.handle_binding import (
+    ConcreteHandleBinding,
     HandleBinding,
-    SlicedHandleBinding,
-    SubscriptHandleBinding,
 )
 from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumAssignmentOperation,
 )
+from classiq.interface.model.quantum_statement import HandleMetadata
 from classiq.interface.model.quantum_type import QuantumBit, QuantumNumeric, QuantumType
 
-from classiq.exceptions import ClassiqValueError
-
 MULTI_VARS_UNSUPPORTED_ERROR = (
     "Amplitude Loading with more than one input variable is unsupported."
 )
 
-VAR_DOMAIN_ILLEGAL = (
-    "Amplitude Loading input variable should be a fixed-point number between 0 and 1"
-)
+VAR_TYPE_ILLEGAL = "Amplitude Loading input variable should be a quantum numeric"
 
 
 class AmplitudeLoadingOperation(QuantumAssignmentOperation):
+    kind: Literal["AmplitudeLoadingOperation"]
+
     _result_type: QuantumType = pydantic.PrivateAttr(default_factory=QuantumBit)
 
     @property
     def wiring_inouts(
         self,
-    ) -> Mapping[
-        str, Union[SlicedHandleBinding, SubscriptHandleBinding, HandleBinding]
-    ]:
+    ) -> Mapping[str, ConcreteHandleBinding]:
         inouts = {self.result_name(): self.result_var}
         if len(self.var_handles) == 1:
             inouts[AMPLITUDE_IO_NAME] = self.var_handles[0]
         return inouts
 
+    @property
+    def readable_inouts(self) -> Sequence[HandleMetadata]:
+        inouts = [
+            HandleMetadata(
+                handle=self.result_var,
+                readable_location="on the left-hand side of an in-place assignment",
+            )
+        ]
+        if len(self.var_handles) == 1:
+            inouts.append(
+                HandleMetadata(
+                    handle=self.var_handles[0],
+                    readable_location="in an expression",
+                )
+            )
+        return inouts
+
     @property
     def wiring_outputs(self) -> Mapping[str, HandleBinding]:
         return {}
 
     def initialize_var_types(
         self,
-        var_types: Dict[str, QuantumType],
+        var_types: dict[str, QuantumType],
         machine_precision: int,
     ) -> None:
         if len(var_types) != 1:
             raise ClassiqValueError(MULTI_VARS_UNSUPPORTED_ERROR)
-        var_type = var_types[self.var_handles[0].name]
-        if not (
-            isinstance(var_type, QuantumNumeric)
-            and var_type.fraction_digits_value == var_type.size_in_bits
-        ):
-            raise ClassiqValueError(VAR_DOMAIN_ILLEGAL)
+        var_type = list(var_types.values())[0]
+        if not isinstance(var_type, QuantumNumeric):
+            raise ClassiqValueError(VAR_TYPE_ILLEGAL)
         super().initialize_var_types(var_types, machine_precision)
 
     @classmethod

classiq/interface/model/quantum_expressions/arithmetic_operation.py

@@ -1,30 +1,43 @@
-from typing import Dict, Mapping, Union
-
-import pydantic
+from collections.abc import Mapping, Sequence
+from typing import Literal
 
+from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.arith.arithmetic import (
     ARITHMETIC_EXPRESSION_RESULT_NAME,
     compute_arithmetic_result_type,
 )
 from classiq.interface.model.handle_binding import (
+    ConcreteHandleBinding,
     HandleBinding,
-    SlicedHandleBinding,
-    SubscriptHandleBinding,
 )
 from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumAssignmentOperation,
 )
+from classiq.interface.model.quantum_statement import HandleMetadata
 from classiq.interface.model.quantum_type import QuantumType
 
 
+class ArithmeticOperationKind(StrEnum):
+    InplaceAdd = "inplace_add"
+    Assignment = "assignment"
+    InplaceXor = "inplace_xor"
+
+
 class ArithmeticOperation(QuantumAssignmentOperation):
-    inplace_result: bool = pydantic.Field(
-        description="Determines whether the result variable is initialized",
-    )
+    kind: Literal["ArithmeticOperation"]
+
+    operation_kind: ArithmeticOperationKind
+
+    @property
+    def is_inplace(self) -> bool:
+        return self.operation_kind in (
+            ArithmeticOperationKind.InplaceXor,
+            ArithmeticOperationKind.InplaceAdd,
+        )
 
     def initialize_var_types(
         self,
-        var_types: Dict[str, QuantumType],
+        var_types: dict[str, QuantumType],
         machine_precision: int,
     ) -> None:
         super().initialize_var_types(var_types, machine_precision)
@@ -35,20 +48,44 @@ class ArithmeticOperation(QuantumAssignmentOperation):
     @property
     def wiring_inouts(
         self,
-    ) -> Mapping[
-        str, Union[SlicedHandleBinding, SubscriptHandleBinding, HandleBinding]
-    ]:
+    ) -> Mapping[str, ConcreteHandleBinding]:
         inouts = dict(super().wiring_inouts)
-        if self.inplace_result:
+        if self.is_inplace:
             inouts[self.result_name()] = self.result_var
         return inouts
 
+    @property
+    def readable_inouts(self) -> Sequence[HandleMetadata]:
+        inouts = [
+            HandleMetadata(handle=handle, readable_location="in an expression")
+            for handle in self.var_handles
+        ]
+        if self.is_inplace:
+            inouts.append(
+                HandleMetadata(
+                    handle=self.result_var,
+                    readable_location="on the left-hand side of an in-place assignment",
+                )
+            )
+        return inouts
+
     @property
     def wiring_outputs(self) -> Mapping[str, HandleBinding]:
-        if self.inplace_result:
+        if self.is_inplace:
             return {}
         return super().wiring_outputs
 
+    @property
+    def readable_outputs(self) -> Sequence[HandleMetadata]:
+        if self.is_inplace:
+            return []
+        return [
+            HandleMetadata(
+                handle=self.result_var,
+                readable_location="on the left-hand side of an assignment",
+            )
+        ]
+
     @classmethod
     def result_name(cls) -> str:
         return ARITHMETIC_EXPRESSION_RESULT_NAME

classiq/interface/model/quantum_expressions/quantum_expression.py

@@ -1,77 +1,54 @@
 import abc
-import ast
-from typing import Dict, List, Mapping, Optional, Set, Union
+from collections.abc import Mapping
+from typing import Optional
 
 import pydantic
 
-from classiq.interface.generator.arith.arithmetic_expression_validator import (
-    DEFAULT_SUPPORTED_FUNC_NAMES,
-)
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.sympy_supported_expressions import (
-    SYMPY_SUPPORTED_EXPRESSIONS,
-)
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.model.handle_binding import (
+    ConcreteHandleBinding,
     HandleBinding,
-    SlicedHandleBinding,
-    SubscriptHandleBinding,
 )
 from classiq.interface.model.quantum_statement import QuantumOperation
 from classiq.interface.model.quantum_type import QuantumType
 
 
-class VarRefCollector(ast.NodeVisitor):
-    def __init__(self) -> None:
-        self.var_names: Set[str] = set()
-
-    def generic_visit(self, node: ast.AST) -> None:
-        if isinstance(node, ast.Name) and node.id not in set(
-            SYMPY_SUPPORTED_EXPRESSIONS
-        ) | set(DEFAULT_SUPPORTED_FUNC_NAMES):
-            self.var_names.add(node.id)
-        super().generic_visit(node)
-
-
 class QuantumExpressionOperation(QuantumOperation):
     expression: Expression = pydantic.Field()
-    _var_handles: List[HandleBinding] = pydantic.PrivateAttr(
+    _var_handles: list[HandleBinding] = pydantic.PrivateAttr(
         default_factory=list,
     )
-    _var_types: Dict[str, QuantumType] = pydantic.PrivateAttr(
+    _var_types: dict[str, QuantumType] = pydantic.PrivateAttr(
         default_factory=dict,
     )
 
     @property
-    def var_handles(self) -> List[HandleBinding]:
+    def var_handles(self) -> list[HandleBinding]:
         return self._var_handles
 
-    def set_var_handles(self, var_handles: List[HandleBinding]) -> None:
+    def set_var_handles(self, var_handles: list[HandleBinding]) -> None:
         self._var_handles = var_handles
 
     @property
-    def var_types(self) -> Dict[str, QuantumType]:
+    def var_types(self) -> dict[str, QuantumType]:
         return self._var_types
 
     def initialize_var_types(
         self,
-        var_types: Dict[str, QuantumType],
+        var_types: dict[str, QuantumType],
         machine_precision: int,
     ) -> None:
-        assert len(var_types) == len(self.var_handles)
+        assert len(var_types) == len(self.var_handles) or len(self.var_handles) == 0
         self._var_types = var_types
 
     @property
-    def wiring_inouts(
-        self,
-    ) -> Mapping[
-        str, Union[SlicedHandleBinding, SubscriptHandleBinding, HandleBinding]
-    ]:
+    def wiring_inouts(self) -> Mapping[str, ConcreteHandleBinding]:
         return nameables_to_dict(self.var_handles)
 
 
 class QuantumAssignmentOperation(QuantumExpressionOperation):
-    result_var: HandleBinding = pydantic.Field(
+    result_var: ConcreteHandleBinding = pydantic.Field(
         description="The variable storing the expression result"
     )
     _result_type: Optional[QuantumType] = pydantic.PrivateAttr(