classiq 0.94.1__py3-none-any.whl → 0.95.0__py3-none-any.whl

classiq/qmod/builtins/operations.py

@@ -1,11 +1,14 @@
 import inspect
 import sys
 from collections.abc import Callable, Mapping
+from functools import wraps
 from types import FrameType
 from typing import (
     Any,
     Final,
     NoReturn,
+    ParamSpec,
+    TypeVar,
     overload,
 )
 
@@ -50,11 +53,25 @@ from classiq.qmod.qmod_constant import QConstant
 from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QNum, QScalar, QVar
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_expandable import prepare_arg
+from classiq.qmod.semantics.error_manager import ErrorManager
 from classiq.qmod.symbolic_expr import SymbolicExpr
 from classiq.qmod.utilities import Statements, get_source_ref, suppress_return_value
 
 _MISSING_VALUE: Final[int] = -1
 
+Params = ParamSpec("Params")
+RetType = TypeVar("RetType")
+
+
+def qmod_statement(func: Callable[Params, RetType]) -> Callable[Params, RetType]:
+    @wraps(func)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        source_ref = get_source_ref(sys._getframe(1))
+        with ErrorManager().source_ref_context(source_ref):
+            return func(*args, **kwargs)
+
+    return wrapper
+
 
 @overload
 def allocate(num_qubits: int | SymbolicExpr, out: Output[QVar]) -> None:
@@ -77,6 +94,7 @@ def allocate(
 
 
 @suppress_return_value
+@qmod_statement
 def allocate(*args: Any, **kwargs: Any) -> None:
     """
     Initialize a quantum variable to a new quantum object in the zero state:
@@ -100,29 +118,34 @@ def allocate(*args: Any, **kwargs: Any) -> None:
         2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
     """
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
     if len(args) == 0:
         size = kwargs.get("num_qubits", None)
         is_signed = kwargs.get("is_signed", None)
         fraction_digits = kwargs.get("fraction_digits", None)
-        target = kwargs["out"]
+        out = kwargs["out"]
     elif len(args) == 1:
         if "out" in kwargs:
             size = args[0]
             is_signed = kwargs.get("is_signed", None)
             fraction_digits = kwargs.get("fraction_digits", None)
-            target = kwargs["out"]
+            out = kwargs["out"]
         else:
             size = None
             is_signed = None
             fraction_digits = None
-            target = args[0]
+            out = args[0]
     elif len(args) == 2:
-        size, target = args
+        size, out = args
         is_signed = kwargs.get("is_signed", None)
         fraction_digits = kwargs.get("fraction_digits", None)
     else:
-        size, is_signed, fraction_digits, target = args
+        size, is_signed, fraction_digits, out = args
+    if not isinstance(out, QVar):
+        raise ClassiqValueError(
+            f"Argument 'out' of operator 'allocate' must be a quantum variable, got "
+            f"{type(out).__name__}"
+        )
     if isinstance(size, QConstant):
         size.add_to_model()
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
@@ -134,13 +157,14 @@ def allocate(*args: Any, **kwargs: Any) -> None:
                 if fraction_digits is None
                 else Expression(expr=str(fraction_digits))
             ),
-            target=target.get_handle_binding(),
+            target=out.get_handle_binding(),
             source_ref=source_ref,
         )
     )
 
 
 @suppress_return_value
+@qmod_statement
 def bind(
     source: Input[QVar] | list[Input[QVar]],
     destination: Output[QVar] | list[Output[QVar]],
@@ -162,7 +186,7 @@ def bind(
     For more details, see [Qmod Reference](https://docs.classiq.io/latest/qmod-reference/language-reference/statements/bind).
     """
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
     if not isinstance(source, list):
         source = [source]
     if not isinstance(destination, list):
@@ -177,6 +201,7 @@ def bind(
 
 
 @suppress_return_value
+@qmod_statement
 def if_(
     condition: SymbolicExpr | bool,
     then: QCallable | Callable[[], Statements],
@@ -198,7 +223,7 @@ def if_(
     if else_ != _MISSING_VALUE:
         _validate_operand(else_)
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
 
     if_stmt = ClassicalIf(
         condition=Expression(expr=str(condition)),
@@ -214,6 +239,7 @@ def if_(
 
 
 @suppress_return_value
+@qmod_statement
 def control(
     ctrl: SymbolicExpr | QBit | QArray[QBit] | list[QVar],
     stmt_block: QCallable | Callable[[], Statements],
@@ -237,7 +263,7 @@ def control(
     """
     _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
     control_stmt = Control(
         expression=Expression(expr=str(ctrl)),
         body=_operand_to_body(stmt_block, "stmt_block"),
@@ -252,6 +278,7 @@ def control(
 
 
 @suppress_return_value
+@qmod_statement
 def skip_control(stmt_block: QCallable | Callable[[], Statements]) -> None:
     """
     Applies quantum statements unconditionally.
@@ -263,7 +290,7 @@ def skip_control(stmt_block: QCallable | Callable[[], Statements]) -> None:
     """
     _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
     sc_stmt = SkipControl(
         body=_operand_to_body(stmt_block, "stmt_block"),
         source_ref=source_ref,
@@ -274,6 +301,7 @@ def skip_control(stmt_block: QCallable | Callable[[], Statements]) -> None:
 
 
 @suppress_return_value
+@qmod_statement
 def assign(expression: SymbolicExpr, target_var: QScalar) -> None:
     """
     Initialize a scalar quantum variable using an arithmetic expression.
@@ -287,7 +315,7 @@ def assign(expression: SymbolicExpr, target_var: QScalar) -> None:
         target_var: An uninitialized scalar quantum variable
     """
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         ArithmeticOperation(
             expression=Expression(expr=str(expression)),
@@ -299,6 +327,7 @@ def assign(expression: SymbolicExpr, target_var: QScalar) -> None:
 
 
 @suppress_return_value
+@qmod_statement
 def assign_amplitude(expression: SymbolicExpr, target_var: QScalar) -> None:
     """
     Perform an amplitude-encoding assignment operation on a quantum variable and a
@@ -311,7 +340,7 @@ def assign_amplitude(expression: SymbolicExpr, target_var: QScalar) -> None:
         target_var: A scalar quantum variable
     """
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         AmplitudeLoadingOperation(
             expression=Expression(expr=str(expression)),
@@ -322,6 +351,7 @@ def assign_amplitude(expression: SymbolicExpr, target_var: QScalar) -> None:
 
 
 @suppress_return_value
+@qmod_statement
 def inplace_add(expression: SymbolicExpr, target_var: QScalar) -> None:
     """
     Add an arithmetic expression to a quantum variable.
@@ -333,7 +363,7 @@ def inplace_add(expression: SymbolicExpr, target_var: QScalar) -> None:
         target_var: A scalar quantum variable
     """
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         ArithmeticOperation(
             expression=Expression(expr=str(expression)),
@@ -345,6 +375,7 @@ def inplace_add(expression: SymbolicExpr, target_var: QScalar) -> None:
 
 
 @suppress_return_value
+@qmod_statement
 def inplace_xor(expression: SymbolicExpr, target_var: QScalar) -> None:
     """
     Bitwise-XOR a quantum variable with an arithmetic expression.
@@ -356,7 +387,7 @@ def inplace_xor(expression: SymbolicExpr, target_var: QScalar) -> None:
         target_var: A scalar quantum variable
     """
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         ArithmeticOperation(
             expression=Expression(expr=str(expression)),
@@ -368,6 +399,7 @@ def inplace_xor(expression: SymbolicExpr, target_var: QScalar) -> None:
 
 
 @suppress_return_value
+@qmod_statement
 def within_apply(
     within: Callable[[], Statements],
     apply: Callable[[], Statements],
@@ -387,7 +419,7 @@ def within_apply(
     _validate_operand(within)
     _validate_operand(apply)
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
     within_apply_stmt = WithinApply(
         compute=_operand_to_body(within, "within"),
         action=_operand_to_body(apply, "apply"),
@@ -400,6 +432,7 @@ def within_apply(
 
 
 @suppress_return_value
+@qmod_statement
 def repeat(count: SymbolicExpr | int, iteration: Callable[[int], Statements]) -> None:
     """
     Executes a quantum loop a specified number of times, applying a quantum operation on each iteration.
@@ -426,7 +459,7 @@ def repeat(count: SymbolicExpr | int, iteration: Callable[[int], Statements]) ->
     """
     _validate_operand(iteration, num_params=1)
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
     iteration_operand = prepare_arg(
         QuantumOperandDeclaration(
             name=REPEAT_OPERATOR_NAME,
@@ -455,6 +488,7 @@ def repeat(count: SymbolicExpr | int, iteration: Callable[[int], Statements]) ->
 
 
 @suppress_return_value
+@qmod_statement
 def power(
     exponent: SymbolicExpr | int,
     stmt_block: QCallable | Callable[[], Statements],
@@ -489,7 +523,7 @@ def power(
     """
     _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
     power_stmt = Power(
         power=Expression(expr=str(exponent)),
         body=_operand_to_body(stmt_block, "stmt_block"),
@@ -501,6 +535,7 @@ def power(
 
 
 @suppress_return_value
+@qmod_statement
 def invert(stmt_block: QCallable | Callable[[], Statements]) -> None:
     """
     Apply the inverse of a quantum gate.
@@ -525,7 +560,7 @@ def invert(stmt_block: QCallable | Callable[[], Statements]) -> None:
     """
     _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
     invert_stmt = Invert(
         body=_operand_to_body(stmt_block, "stmt_block"), source_ref=source_ref
     )
@@ -535,6 +570,7 @@ def invert(stmt_block: QCallable | Callable[[], Statements]) -> None:
 
 
 @suppress_return_value
+@qmod_statement
 def phase(
     phase_expr: SymbolicExpr | float | None = None,
     theta: SymbolicExpr | float = 1.0,
@@ -557,7 +593,7 @@ def phase(
         they are equivalent when the phase_expr is a single-qubit variable.
     """
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         PhaseOperation(
             expression=Expression(expr=str(phase_expr)),
@@ -568,12 +604,13 @@ def phase(
 
 
 @suppress_return_value
+@qmod_statement
 def block(
     statements: QCallable | Callable[[], Statements],
 ) -> None:
     _validate_operand(statements)
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
 
     block_stmt = Block(
         statements=_operand_to_body(statements, "statements"),
@@ -601,13 +638,14 @@ def reset_bounds(
 
 
 @suppress_return_value
+@qmod_statement
 def reset_bounds(
     target_var: QNum,
     lower_bound: float | SymbolicExpr | None = None,
     upper_bound: float | SymbolicExpr | None = None,
 ) -> None:
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
 
     lower_bound_expr = (
         None if lower_bound is None else Expression(expr=str(lower_bound))

classiq/qmod/builtins/structs.py

@@ -3,6 +3,7 @@ from typing import Union
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.helpers.datastructures import LenList
 from classiq.interface.helpers.text_utils import are, readable_list, s
 
 from classiq.qmod.builtins.enums import Pauli
@@ -69,13 +70,15 @@ class SparsePauliOp:
     def __mul__(self, obj: Union[float, "SparsePauliOp"]) -> "SparsePauliOp":
         if isinstance(obj, (int, float, complex)):
             return SparsePauliOp(
-                terms=[
-                    SparsePauliTerm(
-                        paulis=term.paulis,
-                        coefficient=obj * term.coefficient,  # type:ignore[arg-type]
-                    )
-                    for term in self.terms
-                ],
+                terms=LenList(
+                    [
+                        SparsePauliTerm(
+                            paulis=term.paulis,
+                            coefficient=obj * term.coefficient,  # type:ignore[arg-type]
+                        )
+                        for term in self.terms
+                    ]
+                ),
                 num_qubits=self.num_qubits,
             )
         if len(self.terms) != 1 or len(obj.terms) != 1:
@@ -97,14 +100,17 @@ class SparsePauliOp:
                 f"already assigned"
             )
         return SparsePauliOp(
-            terms=[
-                SparsePauliTerm(
-                    paulis=self.terms[0].paulis
-                    + obj.terms[0].paulis,  # type:ignore[arg-type]
-                    coefficient=self.terms[0].coefficient
-                    * obj.terms[0].coefficient,  # type:ignore[arg-type]
-                )
-            ],
+            terms=LenList(
+                [
+                    SparsePauliTerm(
+                        paulis=LenList(  # type:ignore[call-overload]
+                            self.terms[0].paulis + obj.terms[0].paulis
+                        ),
+                        coefficient=self.terms[0].coefficient
+                        * obj.terms[0].coefficient,  # type:ignore[arg-type]
+                    )
+                ]
+            ),
             num_qubits=max(self.num_qubits, obj.num_qubits),
         )
 
@@ -113,7 +119,7 @@ class SparsePauliOp:
 
     def __add__(self, other: "SparsePauliOp") -> "SparsePauliOp":
         return SparsePauliOp(
-            terms=self.terms + other.terms,
+            terms=LenList(self.terms + other.terms),
             num_qubits=max(self.num_qubits, other.num_qubits),
         )
 
@@ -156,21 +162,6 @@ class LogNormalModel:
     sigma: CReal
 
 
-@dataclass
-class QsvmResult:
-    test_score: CReal
-    predicted_labels: CArray[CReal]
-
-
-@dataclass
-class QSVMFeatureMapPauli:
-    feature_dimension: CInt
-    reps: CInt
-    entanglement: CInt
-    alpha: CReal
-    paulis: CArray[CArray[Pauli]]
-
-
 BUILTIN_STRUCT_DECLARATIONS = {
     struct_decl.__name__: StructDeclaration(
         name=struct_decl.__name__,
@@ -190,8 +181,6 @@ __all__ = [
     "IndexedPauli",
     "LogNormalModel",
     "PauliTerm",
-    "QSVMFeatureMapPauli",
-    "QsvmResult",
     "SparsePauliOp",
     "SparsePauliTerm",
 ]

classiq/qmod/semantics/annotation/call_annotation.py

@@ -4,7 +4,7 @@ from typing import Any
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.model.model import Model
-from classiq.interface.model.model_visitor import ModelVisitor
+from classiq.interface.model.model_visitor import ModelStatementsVisitor
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
@@ -47,7 +47,7 @@ def _annotate_function_call_decl(
                 qlambda.set_op_decl(param)
 
 
-class _CallLambdaAnnotator(ModelVisitor):
+class _CallLambdaAnnotator(ModelStatementsVisitor):
     def __init__(
         self, quantum_functions: Mapping[str, QuantumFunctionDeclaration]
     ) -> None:
@@ -76,7 +76,7 @@ class _CallLambdaAnnotator(ModelVisitor):
         _annotate_function_call_decl(
             call, self._quantum_functions | self._current_operands
         )
-        self.generic_visit(call)
+        self.visit(call.positional_args)
 
 
 def resolve_function_calls(

classiq/qmod/semantics/error_manager.py

@@ -1,7 +1,6 @@
 from collections.abc import Iterator
 from contextlib import contextmanager
 
-from classiq.interface.ast_node import ASTNode
 from classiq.interface.exceptions import CLASSIQ_SLACK_COMMUNITY_LINK
 from classiq.interface.source_reference import SourceReference, SourceReferencedError
 
@@ -18,14 +17,14 @@ class ErrorManager:
         self._instantiated = True
         self._errors: list[SourceReferencedError] = []
         self._warnings: list[SourceReferencedError] = []
-        self._current_nodes_stack: list[ASTNode] = []
+        self._current_refs_stack: list[SourceReference | None] = []
         self._call_stack: list[str] = []
         self._ignore_errors: bool = False
 
     @property
     def _current_source_ref(self) -> SourceReference | None:
-        if self._current_nodes_stack:
-            return self._current_nodes_stack[-1].source_ref
+        if self._current_refs_stack:
+            return self._current_refs_stack[-1]
         return None
 
     @contextmanager
@@ -79,7 +78,7 @@ class ErrorManager:
         self.clear_warnings()
 
     def clear_errors(self) -> None:
-        self._current_nodes_stack = []
+        self._current_refs_stack = []
         self._errors = []
 
     def clear_warnings(self) -> None:
@@ -108,10 +107,10 @@ class ErrorManager:
         return self._call_stack[-1] if self._call_stack else None
 
     @contextmanager
-    def node_context(self, node: ASTNode) -> Iterator[None]:
-        self._current_nodes_stack.append(node)
+    def source_ref_context(self, ref: SourceReference | None) -> Iterator[None]:
+        self._current_refs_stack.append(ref)
         yield
-        self._current_nodes_stack.pop()
+        self._current_refs_stack.pop()
 
     @contextmanager
     def call(self, func_name: str) -> Iterator[None]:

{classiq-0.94.1.dist-info → classiq-0.95.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: classiq
-Version: 0.94.1
+Version: 0.95.0
 Summary: Classiq's Python SDK for quantum computing
 Keywords: quantum computing,quantum circuits,quantum algorithms,QAD,QDL
 Author: Classiq Technologies