classiq 0.66.1__py3-none-any.whl → 0.68.0__py3-none-any.whl

classiq/interface/generator/reset.py

@@ -0,0 +1,14 @@
+from classiq.interface.generator.arith.register_user_input import (
+    RegisterArithmeticInfo,
+    RegisterUserInput,
+)
+from classiq.interface.generator.function_params import FunctionParams
+
+
+class Reset(FunctionParams):
+    target: RegisterUserInput
+
+    def _create_ios(self) -> None:
+        mapping: dict[str, RegisterArithmeticInfo] = {self.target.name: self.target}
+        self._inputs = mapping
+        self._outputs = mapping

classiq/interface/generator/types/enum_declaration.py

@@ -1,5 +1,6 @@
 from collections import Counter
 from enum import Enum, EnumMeta, IntEnum
+from typing import Any, Callable
 
 import pydantic
 
@@ -7,6 +8,33 @@ from classiq.interface.ast_node import HashableASTNode
 from classiq.interface.exceptions import ClassiqValueError
 
 
+def rebuild_dynamic_enum(name: str, members: dict[str, int]) -> type[IntEnum]:
+    """
+    Rebuilds the dynamic enum from its name and members.
+    Returns a new enum type.
+    """
+    new_enum = IntEnum(name, members)  # type: ignore[misc]
+    setattr(new_enum, "__members_data__", members)  # noqa: B010
+    setattr(new_enum, "__reduce_ex__", dynamic_enum_reduce_ex)  # noqa: B010
+    return new_enum
+
+
+def dynamic_enum_reduce_ex(
+    obj: Any, protocol: int
+) -> tuple[Callable[..., type[IntEnum]], tuple[str, dict[str, int]]]:
+    """
+    Custom __reduce_ex__ for dynamic enums.
+    This function will be used when pickling an enum type or one of its members.
+    """
+    # Get the enum type and its member data.
+    enum_type = type(obj)
+    members = getattr(enum_type, "__members_data__", None)
+    if members is None:
+        raise ValueError("Dynamic enum is missing __members_data__ attribute")
+    # Return the callable and arguments needed to rebuild the enum type.
+    return rebuild_dynamic_enum, (enum_type.__name__, members)
+
+
 class EnumDeclaration(HashableASTNode):
     name: str
 
@@ -39,8 +67,11 @@ class EnumDeclaration(HashableASTNode):
 
         return members
 
-    def create_enum(self) -> IntEnum:
-        return IntEnum(self.name, self.members)
+    def create_enum(self) -> type[IntEnum]:
+        dynamic_enum = IntEnum(self.name, self.members)  # type: ignore[misc]
+        setattr(dynamic_enum, "__members_data__", self.members)  # noqa: B010
+        setattr(dynamic_enum, "__reduce_ex__", dynamic_enum_reduce_ex)  # noqa: B010
+        return dynamic_enum
 
 
 def declaration_from_enum(enum_type: EnumMeta) -> EnumDeclaration:

classiq/interface/generator/ucc.py

@@ -38,7 +38,7 @@ class UCC(ChemistryFunctionParams):
         description="Maximum depth of the generated quantum circuit ansatz",
     )
     parameter_prefix: str = pydantic.Field(
-        default="param_",
+        default="ucc_param_",
         description="Prefix for the generated parameters",
     )
 

classiq/interface/interface_version.py

@@ -1 +1 @@
-INTERFACE_VERSION = "7"
+INTERFACE_VERSION = "8"

classiq/interface/model/classical_if.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Literal
 
-from classiq.interface.ast_node import ASTNodeType, without_statement_blocks
+from classiq.interface.ast_node import ASTNodeType, reset_lists
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_statement import QuantumOperation
 
@@ -16,4 +16,4 @@ class ClassicalIf(QuantumOperation):
     else_: "StatementBlock"
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
-        return without_statement_blocks(self, ["then", "else_"])
+        return reset_lists(self, ["then", "else_"])

classiq/interface/model/control.py

@@ -2,7 +2,7 @@ from typing import TYPE_CHECKING, Literal, Optional
 
 import pydantic
 
-from classiq.interface.ast_node import ASTNodeType, without_statement_blocks
+from classiq.interface.ast_node import ASTNodeType, reset_lists
 from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
 from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumExpressionOperation,
@@ -46,4 +46,4 @@ class Control(QuantumExpressionOperation):
         )
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
-        return without_statement_blocks(self, ["body", "else_block"])
+        return reset_lists(self, ["body", "else_block"])

classiq/interface/model/invert.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Literal
 
-from classiq.interface.ast_node import ASTNodeType, without_statement_blocks
+from classiq.interface.ast_node import ASTNodeType, reset_lists
 from classiq.interface.model.quantum_statement import QuantumOperation
 
 if TYPE_CHECKING:
@@ -13,4 +13,4 @@ class Invert(QuantumOperation):
     body: "StatementBlock"
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
-        return without_statement_blocks(self, ["body"])
+        return reset_lists(self, ["body"])

classiq/interface/model/power.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Literal
 
-from classiq.interface.ast_node import ASTNodeType, without_statement_blocks
+from classiq.interface.ast_node import ASTNodeType, reset_lists
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_statement import QuantumOperation
 
@@ -15,4 +15,4 @@ class Power(QuantumOperation):
     body: "StatementBlock"
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
-        return without_statement_blocks(self, ["body"])
+        return reset_lists(self, ["body"])

classiq/interface/model/quantum_function_call.py

@@ -7,6 +7,7 @@ from typing import (
 
 import pydantic
 
+from classiq.interface.ast_node import ASTNodeType, reset_lists
 from classiq.interface.exceptions import ClassiqError, ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
@@ -45,6 +46,9 @@ class QuantumFunctionCall(QuantumOperation):
         default=None
     )
 
+    def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
+        return reset_lists(self, ["positional_args"])
+
     @property
     def func_decl(self) -> QuantumFunctionDeclaration:
         if self._func_decl is None:

classiq/interface/model/quantum_statement.py

@@ -5,6 +5,7 @@ from uuid import UUID, uuid4
 
 import pydantic
 from pydantic import ConfigDict
+from typing_extensions import Self
 
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
@@ -21,6 +22,18 @@ class QuantumStatement(ASTNode):
         description="A unique identifier for this operation", default_factory=uuid4
     )
 
+    def model_copy(
+        self,
+        *,
+        update: Optional[dict[str, Any]] = None,
+        deep: bool = False,
+        keep_uuid: bool = False
+    ) -> Self:
+        if not keep_uuid:
+            update = update or dict()
+            update.setdefault("uuid", uuid4())
+        return super().model_copy(update=update, deep=deep)
+
     @pydantic.model_validator(mode="before")
     @classmethod
     def _set_kind(cls, values: Any) -> dict[str, Any]:

classiq/interface/model/repeat.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Literal
 
-from classiq.interface.ast_node import ASTNodeType, without_statement_blocks
+from classiq.interface.ast_node import ASTNodeType, reset_lists
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_statement import QuantumOperation
 
@@ -16,4 +16,4 @@ class Repeat(QuantumOperation):
     body: "StatementBlock"
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
-        return without_statement_blocks(self, ["body"])
+        return reset_lists(self, ["body"])

classiq/interface/model/statement_block.py

@@ -27,8 +27,8 @@ from classiq.interface.model.within_apply_operation import WithinApply
 
 ConcreteQuantumStatement = Annotated[
     Union[
-        Allocate,
         QuantumFunctionCall,
+        Allocate,
         ArithmeticOperation,
         AmplitudeLoadingOperation,
         VariableDeclarationStatement,

classiq/interface/model/within_apply_operation.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Literal
 
-from classiq.interface.ast_node import ASTNodeType, without_statement_blocks
+from classiq.interface.ast_node import ASTNodeType, reset_lists
 from classiq.interface.model.quantum_statement import QuantumOperation
 
 if TYPE_CHECKING:
@@ -14,4 +14,4 @@ class WithinApply(QuantumOperation):
     action: "StatementBlock"
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
-        return without_statement_blocks(self, ["compute", "action"])
+        return reset_lists(self, ["compute", "action"])

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -21,6 +21,7 @@ from classiq.interface.generator.functions.classical_function_declaration import
 )
 from classiq.interface.generator.functions.classical_type import (
     Bool,
+    ClassicalArray,
     ClassicalList,
     ClassicalType,
     OpaqueHandle,
@@ -64,7 +65,7 @@ def qmod_val_to_python(val: ExpressionValue, qmod_type: ClassicalType) -> Any:
         if isinstance(val, (Enum, int)):
             return val
 
-    elif isinstance(qmod_type, ClassicalList):
+    elif isinstance(qmod_type, (ClassicalArray, ClassicalList)):
         if isinstance(val, list):
             return [qmod_val_to_python(elem, qmod_type.element_type) for elem in val]
 

classiq/model_expansions/capturing/captured_vars.py

@@ -1,7 +1,7 @@
 import dataclasses
 from collections.abc import Sequence
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.exceptions import (
@@ -34,8 +34,8 @@ if TYPE_CHECKING:
     from classiq.model_expansions.closure import FunctionClosure
 
 
-ALREADY_ALLOCATED_MESSAGE = "Cannot allocate variable '{}', it is already initialized"
-ALREADY_FREED_MESSAGE = "Cannot free variable '{}', it is already uninitialized"
+INITIALIZED_VAR_MESSAGE = "Variable '{}' should be uninitialized here"
+UNINITIALIZED_VAR_MESSAGE = "Variable '{}' should be initialized here"
 
 
 class PortDirection(StrEnum):
@@ -103,6 +103,11 @@ class _CapturedHandle:
     def change_direction(self, new_direction: PortDirection) -> "_CapturedHandle":
         return dataclasses.replace(self, direction=new_direction)
 
+    def change_defining_function(
+        self, new_defining_function: "FunctionClosure"
+    ) -> "_CapturedHandle":
+        return dataclasses.replace(self, defining_function=new_defining_function)
+
     def set_propagated(self) -> "_CapturedHandle":
         return dataclasses.replace(self, is_propagated=True)
 
@@ -119,9 +124,13 @@ class _CapturedHandle:
         return dataclasses.replace(self, handle=handle, quantum_type=quantum_type)
 
 
+HandleState = tuple[str, "FunctionClosure", bool]
+
+
 @dataclass
 class CapturedVars:
     _captured_handles: list[_CapturedHandle] = field(default_factory=list)
+    _handle_states: list[HandleState] = field(default_factory=list)
 
     def capture_handle(
         self,
@@ -151,9 +160,25 @@ class CapturedVars:
                 else "allocate"
             )
             raise ClassiqExpansionError(
-                f"Cannot partially {verb} variable {captured_handle.handle.name}"
+                f"Cannot {verb} partial variable {str(captured_handle.handle)!r}"
             )
 
+        # A handle should be in either _captured_handles or _handle_states, but never
+        # both
+
+        new_handle_states = []
+        for var_name, defining_function, handle_state in self._handle_states:
+            if captured_handle.handle.name == var_name and _same_closure(
+                captured_handle.defining_function, defining_function
+            ):
+                # verify variable state
+                self._conjugate_direction(
+                    handle_state, captured_handle.direction, var_name
+                )
+            else:
+                new_handle_states.append((var_name, defining_function, handle_state))
+        self._handle_states = new_handle_states
+
         new_captured_handles = []
         for existing_captured_handle in self._captured_handles:
             if not existing_captured_handle.is_same_var(captured_handle):
@@ -163,8 +188,12 @@ class CapturedVars:
                 existing_captured_handle
             )
             if existing_captured_handle.handle == captured_handle.handle:
-                captured_handle = self._conjugate_direction(
-                    existing_captured_handle, captured_handle
+                captured_handle = captured_handle.change_direction(
+                    self._conjugate_direction(
+                        existing_captured_handle.direction,
+                        captured_handle.direction,
+                        str(captured_handle.handle),
+                    )
                 )
             elif captured_handle.handle.overlaps(existing_captured_handle.handle):
                 captured_handle = self._intersect_handles(
@@ -177,44 +206,43 @@ class CapturedVars:
 
     def _conjugate_direction(
         self,
-        existing_captured_handle: _CapturedHandle,
-        captured_handle: _CapturedHandle,
-    ) -> _CapturedHandle:
-        if existing_captured_handle.direction == PortDirection.Input:
-            if captured_handle.direction == PortDirection.Output:
-                return captured_handle.change_direction(PortDirection.Inout)
-            if captured_handle.direction == PortDirection.Outin:
-                return captured_handle.change_direction(PortDirection.Input)
-            raise ClassiqExpansionError(
-                ALREADY_FREED_MESSAGE.format(captured_handle.handle)
+        source_direction: PortDirection | bool,
+        target_direction: PortDirection,
+        var_name: str,
+    ) -> PortDirection:
+        if isinstance(source_direction, bool):
+            source_direction = (
+                PortDirection.Inout if source_direction else PortDirection.Outin
             )
-        if existing_captured_handle.direction == PortDirection.Output:
-            if captured_handle.direction == PortDirection.Input:
-                return captured_handle.change_direction(PortDirection.Outin)
-            if captured_handle.direction in (
-                PortDirection.Output,
-                PortDirection.Outin,
-            ):
-                raise ClassiqExpansionError(
-                    ALREADY_ALLOCATED_MESSAGE.format(captured_handle.handle)
-                )
-            return captured_handle.change_direction(PortDirection.Output)
-        if existing_captured_handle.direction == PortDirection.Inout:
-            if captured_handle.direction in (
+
+        if source_direction == PortDirection.Input:
+            if target_direction == PortDirection.Output:
+                return PortDirection.Inout
+            if target_direction == PortDirection.Outin:
+                return PortDirection.Input
+            raise ClassiqExpansionError(UNINITIALIZED_VAR_MESSAGE.format(var_name))
+
+        if source_direction == PortDirection.Output:
+            if target_direction == PortDirection.Input:
+                return PortDirection.Outin
+            if target_direction in (
                 PortDirection.Output,
                 PortDirection.Outin,
             ):
-                raise ClassiqExpansionError(
-                    ALREADY_ALLOCATED_MESSAGE.format(captured_handle.handle)
-                )
-        elif captured_handle.direction in (
-            PortDirection.Input,
-            PortDirection.Inout,
-        ):
-            raise ClassiqExpansionError(
-                ALREADY_FREED_MESSAGE.format(captured_handle.handle)
-            )
-        return captured_handle
+                raise ClassiqExpansionError(INITIALIZED_VAR_MESSAGE.format(var_name))
+            return PortDirection.Output
+
+        if source_direction == PortDirection.Inout:
+            if target_direction in (PortDirection.Input, PortDirection.Inout):
+                return target_direction
+            raise ClassiqExpansionError(INITIALIZED_VAR_MESSAGE.format(var_name))
+
+        if source_direction == PortDirection.Outin:
+            if target_direction in (PortDirection.Output, PortDirection.Outin):
+                return target_direction
+            raise ClassiqExpansionError(UNINITIALIZED_VAR_MESSAGE.format(var_name))
+
+        raise ClassiqInternalExpansionError(f"Unexpected direction {source_direction}")
 
     def _intersect_handles(
         self,
@@ -227,7 +255,7 @@ class CapturedVars:
                 PortDirection.Outin,
             ):
                 raise ClassiqExpansionError(
-                    ALREADY_FREED_MESSAGE.format(captured_handle.handle)
+                    UNINITIALIZED_VAR_MESSAGE.format(captured_handle.handle)
                 )
             return existing_captured_handle
 
@@ -237,7 +265,7 @@ class CapturedVars:
                 PortDirection.Outin,
             ):
                 raise ClassiqExpansionError(
-                    ALREADY_ALLOCATED_MESSAGE.format(captured_handle.handle)
+                    INITIALIZED_VAR_MESSAGE.format(captured_handle.handle)
                 )
             return captured_handle
 
@@ -316,16 +344,7 @@ class CapturedVars:
             ]
         )
 
-    def filter_vars(
-        self,
-        current_function: "FunctionClosure",
-        current_declarations: Optional[list[VariableDeclarationStatement]] = None,
-    ) -> "CapturedVars":
-        current_declared_vars = (
-            None
-            if current_declarations is None
-            else {decl.name for decl in current_declarations}
-        )
+    def filter_vars(self, current_function: "FunctionClosure") -> "CapturedVars":
         return CapturedVars(
             _captured_handles=[
                 captured_handle
@@ -333,7 +352,18 @@ class CapturedVars:
                 if not _same_closure(
                     captured_handle.defining_function, current_function
                 )
-                or (
+            ]
+        )
+
+    def filter_var_decls(
+        self, current_declarations: list[VariableDeclarationStatement]
+    ) -> "CapturedVars":
+        current_declared_vars = {decl.name for decl in current_declarations}
+        return CapturedVars(
+            _captured_handles=[
+                captured_handle
+                for captured_handle in self._captured_handles
+                if (
                     current_declared_vars is not None
                     and captured_handle.handle.name not in current_declared_vars
                 )
@@ -376,8 +406,92 @@ class CapturedVars:
             if not captured_handle.is_propagated
         }
 
+    def init_var(self, var_name: str, defining_function: "FunctionClosure") -> None:
+        self._handle_states.append((var_name, defining_function, False))
+
+    def init_params(self, func: "FunctionClosure") -> None:
+        ports = {
+            param.name: param.direction
+            for param in func.positional_arg_declarations
+            if isinstance(param, PortDeclaration)
+        }
+        new_handle_states = [
+            handle_state
+            for handle_state in self._handle_states
+            if handle_state[0] not in ports
+        ]
+        for var_name, direction in ports.items():
+            new_handle_states.append(
+                (
+                    var_name,
+                    func,
+                    PortDirection.load(direction)
+                    in (PortDirection.Input, PortDirection.Inout),
+                )
+            )
+        self._handle_states = new_handle_states
+
+    def _get_handle_states(self) -> list[HandleState]:
+        return self._handle_states + list(
+            {
+                (
+                    captured_handle.handle.name,
+                    captured_handle.defining_function.depth,
+                ): (
+                    captured_handle.handle.name,
+                    captured_handle.defining_function,
+                    captured_handle.direction
+                    in (PortDirection.Output, PortDirection.Inout),
+                )
+                for captured_handle in self._captured_handles
+            }.values()
+        )
+
+    def set_parent(self, parent: "CapturedVars") -> None:
+        self._handle_states += parent._get_handle_states()
+
+    def get_state(self, var_name: str, defining_function: "FunctionClosure") -> bool:
+        for name, func, state in self._handle_states:
+            if name == var_name and _same_closure(func, defining_function):
+                return state
+        for captured_handle in self._captured_handles:
+            if captured_handle.handle.name == var_name and _same_closure(
+                captured_handle.defining_function, defining_function
+            ):
+                return captured_handle.direction in (
+                    PortDirection.Output,
+                    PortDirection.Inout,
+                )
+        raise ClassiqInternalExpansionError(
+            f"Cannot find {var_name!r} from {defining_function.name!r}"
+        )
+
     def clone(self) -> "CapturedVars":
-        return CapturedVars(_captured_handles=list(self._captured_handles))
+        return CapturedVars(
+            _captured_handles=list(self._captured_handles),
+            _handle_states=list(self._handle_states),
+        )
+
+    def set(
+        self,
+        other: "CapturedVars",
+        source_func: "FunctionClosure",
+        target_func: "FunctionClosure",
+    ) -> None:
+        self._captured_handles = []
+        for captured_handle in other._captured_handles:
+            if _same_closure(captured_handle.defining_function, source_func):
+                self._captured_handles.append(
+                    captured_handle.change_defining_function(target_func)
+                )
+            else:
+                self._captured_handles.append(captured_handle)
+        self._handle_states = []
+        for var, defining_function, state in other._handle_states:
+            if _same_closure(defining_function, source_func):
+                self._handle_states.append((var, target_func, state))
+            else:
+                self._handle_states.append((var, defining_function, state))
 
 
 def _same_closure(closure_1: "FunctionClosure", closure_2: "FunctionClosure") -> bool:
@@ -433,3 +547,19 @@ def validate_captured_directions(
         raise ClassiqExpansionError(
             f"Captured quantum variables {captured_outputs!r} cannot be used as outputs"
         )
+
+
+def validate_end_state(func: "FunctionClosure", captured_vars: CapturedVars) -> None:
+    for param in func.positional_arg_declarations:
+        if isinstance(param, PortDeclaration):
+            state = captured_vars.get_state(param.name, func)
+            expected_state = param.direction in (
+                PortDeclarationDirection.Output,
+                PortDeclarationDirection.Inout,
+            )
+            if state != expected_state:
+                status = "initialized" if expected_state else "uninitialized"
+                raise ClassiqExpansionError(
+                    f"At the end of function {func.name}, variable {param.name!r} "
+                    f"should be {status}"
+                )

classiq/model_expansions/closure.py

@@ -83,18 +83,21 @@ class FunctionClosure(Closure):
         scope: Scope,
         body: Optional[Sequence[QuantumStatement]] = None,
         positional_arg_declarations: Sequence[PositionalArg] = tuple(),
-        is_lambda: bool = False,
+        lambda_external_vars: Optional[CapturedVars] = None,
         is_atomic: bool = False,
         **kwargs: Any,
     ) -> Self:
         blocks = {"body": body} if body is not None else {}
+        captured_vars = CapturedVars()
+        if lambda_external_vars is not None:
+            captured_vars.set_parent(lambda_external_vars)
         return cls(
             name,
             blocks,
             scope,
             positional_arg_declarations,
-            CapturedVars(),
-            is_lambda,
+            captured_vars,
+            lambda_external_vars is not None,
             is_atomic,
             **kwargs,
         )