classiq 0.58.0__py3-none-any.whl → 0.59.0__py3-none-any.whl

classiq/model_expansions/quantum_operations/emitter.py

@@ -9,26 +9,28 @@ from typing import (
 
 import sympy
 
+from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
 )
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
 )
 from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
 
-from classiq.model_expansions.capturing.propagated_var_stack import (
-    PropagatedVarStack,
-)
 from classiq.model_expansions.closure import Closure, FunctionClosure, GenerativeClosure
 from classiq.model_expansions.function_builder import (
     FunctionContext,
     OperationBuilder,
     OperationContext,
 )
-from classiq.model_expansions.scope import Scope
+from classiq.model_expansions.scope import QuantumSymbol, Scope
 from classiq.model_expansions.sympy_conversion.sympy_to_python import (
     translate_sympy_quantum_expression,
 )
@@ -69,10 +71,6 @@ class Emitter(Generic[QuantumStatementT]):
             return self._generative_contexts[closure.name]
         return self._interpreter._expand_operation(closure)
 
-    @property
-    def _propagated_var_stack(self) -> PropagatedVarStack:
-        return self._interpreter._propagated_var_stack
-
     @property
     def _builder(self) -> OperationBuilder:
         return self._interpreter._builder
@@ -134,3 +132,33 @@ class Emitter(Generic[QuantumStatementT]):
             value=evaluated_expression.value
         )
         return new_expression
+
+    def emit_statement(self, statement: QuantumStatement) -> None:
+        if isinstance(statement, QuantumOperation):
+            self._update_captured_vars(statement)
+        self._builder.emit_statement(statement)
+
+    def _update_captured_vars(self, op: QuantumOperation) -> None:
+        handles = (
+            [(handle, PortDeclarationDirection.Input) for handle in op.inputs]
+            + [(handle, PortDeclarationDirection.Output) for handle in op.outputs]
+            + [(handle, PortDeclarationDirection.Inout) for handle in op.inouts]
+        )
+        for handle, direction in handles:
+            self._capture_handle(handle, direction)
+
+    def _capture_handle(
+        self, handle: HandleBinding, direction: PortDeclarationDirection
+    ) -> None:
+        if handle.name not in self._current_scope:
+            return
+        defining_function = self._current_scope[handle.name].defining_function
+        if defining_function is None:
+            raise ClassiqInternalExpansionError
+        symbol: QuantumSymbol = self._interpreter.evaluate(handle).value
+        self._builder.current_block.captured_vars.capture_handle(
+            handle=symbol.handle,
+            quantum_type=symbol.quantum_type,
+            defining_function=defining_function,
+            direction=direction,
+        )

classiq/model_expansions/quantum_operations/expression_operation.py

@@ -1,9 +1,7 @@
 import ast
-from typing import TYPE_CHECKING, Generic, TypeVar, Union
+from typing import Generic, TypeVar, Union
 
-from classiq.interface.generator.expressions.evaluated_expression import (
-    EvaluatedExpression,
-)
+from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.visitor import NodeType
 from classiq.interface.model.control import Control
@@ -18,26 +16,16 @@ from classiq.interface.model.within_apply_operation import WithinApply
 
 from classiq.model_expansions.quantum_operations.call_emitter import CallEmitter
 from classiq.model_expansions.scope import QuantumSymbol
-from classiq.model_expansions.transformers.var_splitter import (
-    SymbolParts,
-    VarSplitter,
-)
+from classiq.model_expansions.transformers.var_splitter import SymbolParts
 from classiq.model_expansions.visitors.variable_references import VarRefCollector
 
-if TYPE_CHECKING:
-    from classiq.model_expansions.interpreter import Interpreter
-
 ExpressionOperationT = TypeVar("ExpressionOperationT", bound=QuantumExpressionOperation)
 AST_NODE = TypeVar("AST_NODE", bound=NodeType)
 
 
 class ExpressionOperationEmitter(
-    Generic[ExpressionOperationT], CallEmitter[ExpressionOperationT], VarSplitter
+    Generic[ExpressionOperationT], CallEmitter[ExpressionOperationT]
 ):
-    def __init__(self, interpreter: "Interpreter") -> None:
-        CallEmitter.__init__(self, interpreter)  # type:ignore[arg-type]
-        VarSplitter.__init__(self, interpreter._current_scope)
-
     def _emit_with_split(
         self,
         op: ExpressionOperationT,
@@ -49,9 +37,11 @@ class ExpressionOperationEmitter(
         bind_ops = self.get_bind_ops(symbol_parts)
 
         new_expression = self.rewrite(expression, symbol_parts)
-        new_expression._evaluated_expr = EvaluatedExpression(
-            value=self._interpreter.evaluate(new_expression).value
-        )
+        if len(self.split_symbols(new_expression, lambda name: name)) > 0:
+            raise ClassiqInternalExpansionError(
+                f"Did not replace all handles in expression: {expression.expr!r} -> "
+                f"{new_expression.expr!r}"
+            )
         new_op = op.model_copy(update=dict(expression=new_expression))
         new_op = self._get_updated_op_split_symbols(new_op, symbol_parts)
 

classiq/model_expansions/quantum_operations/inplace_binary_operation.py

@@ -83,8 +83,7 @@ class InplaceBinaryOperationEmitter(CallEmitter[InplaceBinaryOperation]):
             frac_digits_diff == value_var.quantum_type.size_in_bits
             or -frac_digits_diff == target_var.quantum_type.size_in_bits
         ):
-            with self._propagated_var_stack.capture_variables(op):
-                return
+            return
 
         value_var = QuantumSymbol(
             handle=HandleBinding(name="value"), quantum_type=value_var.quantum_type
@@ -122,10 +121,9 @@ class InplaceBinaryOperationEmitter(CallEmitter[InplaceBinaryOperation]):
             body=body,
             scope=Scope(parent=self._current_scope),
         )
-        with self._propagated_var_stack.capture_variables(op):
-            self._emit_quantum_function_call(
-                inplace_binary_op_function, [op.value, op.target]
-            )
+        self._emit_quantum_function_call(
+            inplace_binary_op_function, [op.value, op.target]
+        )
 
     def _emit_constant_operation(self, op: InplaceBinaryOperation) -> None:
         if TYPE_CHECKING:

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.0.dist-info → classiq-0.59.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: classiq
-Version: 0.58.0
+Version: 0.59.0
 Summary: Classiq's Python SDK for quantum computing
 Home-page: https://classiq.io
 License: Proprietary
@@ -45,7 +45,7 @@ Requires-Dist: numpy (>=1.26.0,<2.0.0) ; python_version >= "3.12"
 Requires-Dist: packaging (>=23.2,<24.0)
 Requires-Dist: pandas (>=1.4.0,<3.0.0)
 Requires-Dist: plotly (>=5.7.0,<6.0.0)
-Requires-Dist: pydantic (>=2.9.0,<3.0.0)
+Requires-Dist: pydantic (>=2.9.0,<2.10.0)
 Requires-Dist: pydantic-settings (>=2.4.0,<3.0.0)
 Requires-Dist: scipy (>=1.10.0,<2.0.0) ; python_version < "3.12"
 Requires-Dist: scipy (>=1.11.0,<2.0.0) ; python_version >= "3.12"