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

classiq/interface/model/model.py

@@ -1,7 +1,12 @@
-from typing import Any, Dict, List, Literal, NewType, Optional, Set, Union
+from collections import Counter
+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 (
@@ -10,25 +15,19 @@ 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.combinatorial_problem import (
-    CombinatorialOptimizationStructDeclaration,
-)
+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 (
-    get_discriminator_field,
-    nameables_to_dict,
-)
+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_call import ConcreteQuantumStatement
-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.exceptions import ClassiqValueError
+from classiq.interface.model.statement_block import StatementBlock
 
 USER_MODEL_MARKER = "user"
 
@@ -39,10 +38,6 @@ DEFAULT_PORT_SIZE = 1
 
 SerializedModel = NewType("SerializedModel", str)
 
-ConcreteStructDeclaration = Union[
-    CombinatorialOptimizationStructDeclaration, StructDeclaration
-]
-
 TYPE_NAME_CONFLICT_BUILTIN = (
     "Type '{name}' conflicts with a builtin type with the same name"
 )
@@ -60,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"] = get_discriminator_field(USER_MODEL_MARKER)
+    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,
     )
 
-    types: List[ConcreteStructDeclaration] = pydantic.Field(
+    enums: list[EnumDeclaration] = pydantic.Field(
         default_factory=list,
-        description="The user-defined custom function library.",
+        description="user-defined enums",
+    )
+
+    types: list[StructDeclaration] = pydantic.Field(
+        default_factory=list,
+        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,
     )
 
@@ -93,17 +96,32 @@ 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]
 
     @property
-    def body(self) -> List[ConcreteQuantumStatement]:
+    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(
@@ -114,63 +132,59 @@ 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[ConcreteStructDeclaration]
-    ) -> List[ConcreteStructDeclaration]:
-        user_defined_types: Set[str] = set()
-        for ctype in types:
-            if ctype.name in StructDeclaration.BUILTIN_STRUCT_DECLARATIONS:
-                raise ValueError(TYPE_NAME_CONFLICT_BUILTIN.format(name=ctype.name))
-            if ctype.name in user_defined_types:
-                raise ValueError(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.field_validator("constants")
+    @classmethod
+    def _validate_constants(cls, constants: list[Constant]) -> list[Constant]:
+        constant_definition_counts = Counter(
+            [constant.name for constant in constants]
+        ).items()
+        multiply_defined_constants = {
+            constant for constant, count in constant_definition_counts if count > 1
+        }
+        if len(multiply_defined_constants) > 0:
+            raise ClassiqValueError(
+                f"The following constants were defined more than once: "
+                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,20 +1,23 @@
-from typing import List
+from typing import TYPE_CHECKING
 
 import pydantic
 
-from classiq.interface.model.quantum_function_call import ConcreteQuantumStatement
 from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
-)
-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
 
@@ -22,17 +25,9 @@ class NativeFunctionDefinition(QuantumFunctionDeclaration):
     objects from other classes.
     """
 
-    body: List[ConcreteQuantumStatement] = 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_call(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,58 +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]
-    ]:
-        if len(self.var_handles) == 0:
-            return dict()
-        return {AMPLITUDE_IO_NAME: self.var_handles[0]}
+    ) -> 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 == 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