classiq 0.58.1__py3-none-any.whl → 0.60.0__py3-none-any.whl

classiq/model_expansions/quantum_operations/invert.py

@@ -10,15 +10,12 @@ from classiq.model_expansions.scope import Scope
 
 class InvertEmitter(CallEmitter[Invert]):
     def emit(self, invert: Invert, /) -> None:
-        with self._propagated_var_stack.capture_variables(invert):
-            self._emit_propagated(invert)
-
-    def _emit_propagated(self, invert: Invert, /) -> None:
-        if invert.is_generative():
+        is_generative = invert.is_generative()
+        if is_generative:
             context = self._register_generative_context(invert, INVERT_OPERATOR_NAME)
             invert = invert.model_copy(update={"body": context.statements("body")})
 
-        if self._should_wrap(invert.body):
+        if not is_generative and self._should_wrap(invert.body):
             self._emit_wrapped(invert)
             return
 
@@ -31,7 +28,7 @@ class InvertEmitter(CallEmitter[Invert]):
             scope=Scope(parent=self._current_scope),
         )
         context = self._expand_operation(invert_operation)
-        self._builder.emit_statement(
+        self.emit_statement(
             Invert(body=context.statements("body"), source_ref=invert.source_ref)
         )
 
@@ -39,6 +36,6 @@ class InvertEmitter(CallEmitter[Invert]):
         wrapping_function = self._create_expanded_wrapping_function(
             INVERT_OPERATOR_NAME, invert.body
         )
-        self._builder.emit_statement(
+        self.emit_statement(
             Invert(body=[wrapping_function], source_ref=invert.source_ref)
         )

classiq/model_expansions/quantum_operations/power.py

@@ -22,10 +22,6 @@ class PowerEmitter(CallEmitter[Power]):
     _power_expr: Expression
 
     def emit(self, power: Power, /) -> None:
-        with self._propagated_var_stack.capture_variables(power):
-            self._emit_propagated(power)
-
-    def _emit_propagated(self, power: Power) -> None:
         if power.is_generative():
             context = self._register_generative_context(power, POWER_OPERATOR_NAME)
             power = power.model_copy(update={"body": context.statements("body")})
@@ -50,7 +46,7 @@ class PowerEmitter(CallEmitter[Power]):
             scope=Scope(parent=self._current_scope),
         )
         context = self._expand_operation(power_operation)
-        self._builder.emit_statement(
+        self.emit_statement(
             Power(
                 body=context.statements("body"),
                 power=self._power_expr,
@@ -59,11 +55,10 @@ class PowerEmitter(CallEmitter[Power]):
         )
 
     def _emit_wrapped(self) -> None:
-        with self._propagated_var_stack.capture_variables(self._power):
-            wrapping_function = self._create_expanded_wrapping_function(
-                POWER_OPERATOR_NAME, self._power.body
-            )
-        self._builder.emit_statement(
+        wrapping_function = self._create_expanded_wrapping_function(
+            POWER_OPERATOR_NAME, self._power.body
+        )
+        self.emit_statement(
             Power(
                 body=[wrapping_function],
                 power=self._power_expr,

classiq/model_expansions/quantum_operations/quantum_assignment_operation.py

@@ -79,8 +79,6 @@ class QuantumAssignmentOperationEmitter(
 
     def _emit_op(self, expression: Expression, op: QuantumAssignmentOperation) -> None:
         op = self._evaluate_types_in_expression(op, expression)
-        with self._propagated_var_stack.capture_variables(op):
-            pass  # This propagates the expression variables
         if isinstance(op, ArithmeticOperation):
             self._emit_arithmetic_op(op, expression)
             return
@@ -130,7 +128,7 @@ class QuantumAssignmentOperationEmitter(
     ) -> None:
         result = self._interpreter.evaluate(op.result_var).as_type(QuantumSymbol)
         copy_type_information(op.result_type, result.quantum_type, str(result.handle))
-        self._builder.emit_statement(op)
+        self.emit_statement(op)
 
     def _optimize_boolean_expression(
         self, op: ArithmeticOperation, expression: Expression

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -18,7 +18,5 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
     def emit(self, call: QuantumFunctionCall, /) -> None:
         function = self._interpreter.evaluate(call.function).as_type(FunctionClosure)
         args = call.positional_args
-        with ErrorManager().call(
-            function.name
-        ), function.scope.freeze(), self._propagated_var_stack.capture_variables(call):
+        with ErrorManager().call(function.name), function.freeze():
             self._emit_quantum_function_call(function, args)

classiq/model_expansions/quantum_operations/repeat.py

@@ -23,10 +23,9 @@ class RepeatEmitter(CallEmitter[Repeat]):
                 f"repeat count must be non-negative, got {count}"
             )
         for i in range(count):
-            with self._propagated_var_stack.capture_variables(repeat):
-                self._emit_propagated(repeat, i)
+            self._emit_iteration(repeat, i)
 
-    def _emit_propagated(self, repeat: Repeat, i: int) -> None:
+    def _emit_iteration(self, repeat: Repeat, i: int) -> None:
         closure_constructor: type[FunctionClosure]
         extra_args: dict
         if repeat.is_generative():
@@ -50,6 +49,7 @@ class RepeatEmitter(CallEmitter[Repeat]):
             ],
             body=repeat.body,
             scope=Scope(parent=self._current_scope),
+            is_lambda=True,
             **extra_args,
         )
         self._emit_quantum_function_call(iteration_function, [Expression(expr=str(i))])

classiq/model_expansions/quantum_operations/variable_decleration.py

@@ -25,4 +25,4 @@ class VariableDeclarationStatementEmitter(Emitter[VariableDeclarationStatement])
             ),
             defining_function=self._builder.current_function,
         )
-        self._builder.emit_statement(var_decl)
+        self.emit_statement(var_decl)

classiq/model_expansions/quantum_operations/within_apply.py

@@ -10,10 +10,6 @@ from classiq.model_expansions.scope import Scope
 
 class WithinApplyEmitter(Emitter[WithinApply]):
     def emit(self, within_apply: WithinApply, /) -> None:
-        with self._propagated_var_stack.capture_variables(within_apply):
-            self._emit_propagated(within_apply)
-
-    def _emit_propagated(self, within_apply: WithinApply) -> None:
         if within_apply.is_generative():
             within_apply_context = self._register_generative_context(
                 within_apply, WITHIN_APPLY_NAME, ["within", "apply"]
@@ -34,7 +30,7 @@ class WithinApplyEmitter(Emitter[WithinApply]):
             scope=Scope(parent=self._current_scope),
         )
         context = self._expand_operation(within_apply_operation)
-        self._builder.emit_statement(
+        self.emit_statement(
             WithinApply(
                 compute=context.statements("within"),
                 action=context.statements("apply"),

classiq/model_expansions/scope.py

@@ -34,7 +34,7 @@ from classiq.interface.model.quantum_type import (
 )
 
 if TYPE_CHECKING:
-    from classiq.model_expansions.closure import Closure
+    from classiq.model_expansions.closure import FunctionClosure
 
 T = TypeVar("T")
 
@@ -138,7 +138,7 @@ def _evaluated_to_str_struct_literal(value: QmodStructInstance) -> str:
 @dataclass(frozen=True)
 class Evaluated:  # FIXME: Merge with EvaluatedExpression if possible
     value: Any
-    defining_function: Optional["Closure"] = None
+    defining_function: Optional["FunctionClosure"] = None
 
     def as_type(self, t: type[T]) -> T:
         if t is int:

classiq/model_expansions/transformers/var_splitter.py

@@ -1,7 +1,7 @@
 import ast
 from dataclasses import dataclass
 from itertools import chain
-from typing import TYPE_CHECKING, Callable, TypeVar
+from typing import TYPE_CHECKING, Callable, TypeVar, cast
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -15,6 +15,9 @@ from classiq.interface.model.handle_binding import (
     NestedHandleBinding,
     SlicedHandleBinding,
 )
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumExpressionOperation,
+)
 from classiq.interface.model.quantum_type import (
     QuantumBitvector,
     QuantumScalar,
@@ -54,8 +57,9 @@ class VarSplitter:
         vrc.visit(ast.parse(expression.expr))
         symbol_names_to_split = dict.fromkeys(
             handle.name
-            for handle in self._get_handles(vrc)
-            if isinstance(handle, NestedHandleBinding)
+            for handle in vrc.var_handles
+            if isinstance(self._scope[handle.name].value, QuantumSymbol)
+            and isinstance(handle, NestedHandleBinding)
         )
 
         symbol_handles = {
@@ -85,13 +89,6 @@ class VarSplitter:
             for symbol, handles in symbol_handles.items()
         }
 
-    def _get_handles(self, collector: VarRefCollector) -> list[HandleBinding]:
-        return [
-            handle
-            for handle in collector.var_handles
-            if isinstance(self._scope[handle.name].value, QuantumSymbol)
-        ]
-
     def _get_symbol_parts(
         self, symbol: QuantumSymbol, target_parts: list[HandleBinding]
     ) -> list[QuantumSymbol]:
@@ -184,14 +181,9 @@ class VarSplitter:
             for part in chain.from_iterable(symbol_parts.values())
         ]
 
-    def _check_all_handles_were_replaced(self, new_expr_str: str) -> None:
-        vrc = VarRefCollector(ignore_duplicated_handles=True)
-        vrc.visit(ast.parse(new_expr_str))
-        for handle in self._get_handles(vrc):
-            if isinstance(handle, NestedHandleBinding):
-                raise ClassiqInternalExpansionError(f"Did not replace handle {handle}")
-
     def rewrite(self, subject: AST_NODE, symbol_mapping: SymbolParts) -> AST_NODE:
+        if len(symbol_mapping) == 0:
+            return subject
         handle_replacements = {
             part.source_handle: part.target_var_handle
             for parts in symbol_mapping.values()
@@ -210,6 +202,22 @@ class VarSplitter:
             def visit_Expression(expr: Expression) -> Expression:
                 return self._rewrite_expression(symbol_mapping, expr)
 
+            def visit_QuantumExpressionOperation(
+                self, op: QuantumExpressionOperation
+            ) -> QuantumExpressionOperation:
+                op = cast(QuantumExpressionOperation, self.generic_visit(op))
+                previous_var_handles = list(op._var_handles)
+                op._var_handles = self.visit(op._var_handles)
+                op._var_types = {
+                    new_handle.name: op._var_types.get(
+                        new_handle.name, op._var_types[previous_handle.name]
+                    )
+                    for previous_handle, new_handle in zip(
+                        previous_var_handles, op._var_handles
+                    )
+                }
+                return op
+
         return ReplaceSplitVars().visit(subject)
 
     def _rewrite_expression(
@@ -232,6 +240,11 @@ class VarSplitter:
                 new_expr_str = new_expr_str.replace(
                     str(handle), handle_names[collapsed_handle]
                 )
-        self._check_all_handles_were_replaced(new_expr_str)
+                if handle.qmod_expr != str(handle):
+                    new_expr_str = new_expr_str.replace(
+                        handle.qmod_expr, handle_names[collapsed_handle]
+                    )
 
-        return Expression(expr=new_expr_str)
+        new_expr = Expression(expr=new_expr_str)
+        new_expr._evaluated_expr = expression._evaluated_expr
+        return new_expr

classiq/model_expansions/utils/handles_collector.py

@@ -0,0 +1,33 @@
+import ast
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.visitor import NodeType, Visitor
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumExpressionOperation,
+)
+
+from classiq.model_expansions.visitors.variable_references import VarRefCollector
+
+
+class _HandlesCollector(Visitor):
+    def __init__(self) -> None:
+        self.handles: list[HandleBinding] = []
+
+    def visit_HandleBinding(self, handle: HandleBinding) -> None:
+        self.handles.append(handle)
+
+    def visit_Expression(self, expression: Expression) -> None:
+        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc.visit(ast.parse(expression.expr))
+        self.handles.extend(vrc.var_handles)
+
+    def visit_QuantumExpressionOperation(self, op: QuantumExpressionOperation) -> None:
+        self.handles.extend(op.var_handles)
+        self.generic_visit(op)
+
+
+def extract_handles(node: NodeType) -> list[HandleBinding]:
+    collector = _HandlesCollector()
+    collector.visit(node)
+    return collector.handles

classiq/model_expansions/visitors/variable_references.py

@@ -80,13 +80,29 @@ class VarRefCollector(ast.NodeVisitor):
         return handle
 
     def visit_Attribute(self, node: ast.Attribute) -> Optional[FieldHandleBinding]:
+        return self._get_field_handle(node.value, node.attr)
+
+    def visit_Call(self, node: ast.Call) -> Optional[FieldHandleBinding]:
+        if (
+            not isinstance(node.func, ast.Name)
+            or node.func.id != "get_field"
+            or len(node.args) != 2
+            or not isinstance(node.args[1], ast.Constant)
+            or not isinstance(node.args[1].value, str)
+        ):
+            return self.generic_visit(node)
+        return self._get_field_handle(node.args[0], node.args[1].value)
+
+    def _get_field_handle(
+        self, subject: ast.expr, field: str
+    ) -> Optional[FieldHandleBinding]:
         with self.set_nested():
-            base_handle = self.visit(node.value)
+            base_handle = self.visit(subject)
         if base_handle is None:
             return None
         handle = FieldHandleBinding(
             base_handle=base_handle,
-            field=node.attr,
+            field=field,
         )
         if not self._is_nested:
             self._var_handles[handle] = True

classiq/qmod/qfunc.py

@@ -27,28 +27,24 @@ def set_discovered_functions(
 def qfunc(func: Callable) -> QFunc: ...
 
 
-@overload
-def qfunc(*, synthesize_separately: Literal[True]) -> Callable[[Callable], QFunc]: ...
-
-
-@overload
-def qfunc(*, external: Literal[True]) -> Callable[[Callable], ExternalQFunc]: ...
-
-
 @overload
 def qfunc(
-    *, external: Literal[True], synthesize_separately: Literal[True]
+    *,
+    external: Literal[True],
+    synthesize_separately: Literal[False] = False,
 ) -> Callable[[Callable], ExternalQFunc]: ...
 
 
 @overload
-def qfunc(*, generative: Literal[True]) -> Callable[[Callable], GenerativeQFunc]: ...
+def qfunc(
+    *,
+    generative: Literal[True],
+    synthesize_separately: bool = False,
+) -> Callable[[Callable], GenerativeQFunc]: ...
 
 
 @overload
-def qfunc(
-    *, generative: Literal[True], synthesize_separately: Literal[True]
-) -> Callable[[Callable], GenerativeQFunc]: ...
+def qfunc(*, synthesize_separately: bool) -> Callable[[Callable], QFunc]: ...
 
 
 def qfunc(

classiq/qmod/quantum_expandable.py

@@ -1,5 +1,4 @@
 import inspect
-import warnings
 from abc import ABC
 from dataclasses import is_dataclass
 from enum import Enum as PythonEnum
@@ -19,7 +18,7 @@ import pydantic
 from sympy import Basic
 from typing_extensions import Self
 
-from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqValueError
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.concrete_types import (
     NativePythonClassicalTypes,
@@ -390,7 +389,6 @@ def _get_operand_hint(
 def _prepare_args(
     decl: AnonQuantumFunctionDeclaration, arg_list: list[Any], kwargs: dict[str, Any]
 ) -> list[ArgValue]:
-    _apply_control_backward_compatibility(decl, kwargs)
     result = []
     for idx, arg_decl in enumerate(decl.positional_arg_declarations):
         arg = None
@@ -413,24 +411,6 @@ def _prepare_args(
     return result
 
 
-def _apply_control_backward_compatibility(
-    decl: AnonQuantumFunctionDeclaration, kwargs: dict[str, Any]
-) -> None:
-    from classiq.qmod.builtins.functions import __all__ as builtin_functions
-
-    if decl.name in builtin_functions and "control" in kwargs:
-        warnings.warn(
-            f"Parameter 'control' of function {decl.name!r} has been renamed to "
-            f"'ctrl'. Parameter 'control' will no longer be supported starting on "
-            f"4/11/24 at the earliest.\nHint: Change {decl.name}(control=...) to "
-            f"{decl.name}(ctrl=...).",
-            ClassiqDeprecationWarning,
-            stacklevel=6,
-        )
-        kwargs["ctrl"] = kwargs["control"]
-        kwargs.pop("control")
-
-
 def _create_quantum_function_call(
     decl_: QuantumFunctionDeclaration,
     index_: Optional[Union[CParamScalar, int]] = None,

classiq/qmod/quantum_function.py

@@ -7,6 +7,9 @@ from typing import Any, Callable, Optional, get_origin
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
 from classiq.interface.generator.model.constraints import Constraints
 from classiq.interface.generator.model.preferences.preferences import Preferences
 from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
@@ -37,7 +40,20 @@ class BaseQFunc(QExpandable):
         super().__init__(py_callable)
         self.compilation_metadata = compilation_metadata
 
+    @property
+    def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
+        raise NotImplementedError
+
+    @property
+    def _has_inputs(self) -> bool:
+        return any(
+            port.direction == PortDeclarationDirection.Input
+            for port in self.func_decl.port_declarations
+        )
+
     def update_compilation_metadata(self, **kwargs: Any) -> None:
+        if kwargs["should_synthesize_separately"] and self._has_inputs:
+            raise ClassiqError("Can't synthesize separately a function with inputs")
         self.compilation_metadata = self._compilation_metadata.model_copy(update=kwargs)
 
     @property

{classiq-0.58.1.dist-info → classiq-0.60.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: classiq
-Version: 0.58.1
+Version: 0.60.0
 Summary: Classiq's Python SDK for quantum computing
 Home-page: https://classiq.io
 License: Proprietary