classiq 0.46.1__py3-none-any.whl → 0.48.0__py3-none-any.whl

classiq/qmod/builtins/operations.py

@@ -1,17 +1,13 @@
 import inspect
 import sys
-import warnings
 from types import FrameType
 from typing import (
-    TYPE_CHECKING,
     Any,
     Callable,
     Final,
     List,
     Mapping,
-    Optional,
     Union,
-    overload,
 )
 
 from classiq.interface.exceptions import ClassiqValueError
@@ -31,6 +27,7 @@ from classiq.interface.model.inplace_binary_operation import (
     InplaceBinaryOperation,
 )
 from classiq.interface.model.invert import Invert
+from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.power import Power
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
@@ -79,57 +76,33 @@ def if_(
         _validate_operand(else_)
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))
-    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-        ClassicalIf(
-            condition=Expression(expr=str(condition)),
-            then=_operand_to_body(then, "then"),
-            else_=_operand_to_body(else_, "else") if else_ != _MISSING_VALUE else [],  # type: ignore[arg-type]
-            source_ref=source_ref,
-        )
-    )
-
-
-@overload  # FIXME: Remove overloading (CAD-21932)
-def control(
-    ctrl: Union[QBit, QArray[QBit]], stmt_block: Union[QCallable, Callable[[], None]]
-) -> None:
-    pass
-
 
-@overload
-def control(
-    ctrl: SymbolicExpr, stmt_block: Union[QCallable, Callable[[], None]]
-) -> None:
-    pass
+    if_stmt = ClassicalIf(
+        condition=Expression(expr=str(condition)),
+        then=_operand_to_body(then, "then"),
+        else_=_operand_to_body(else_, "else") if else_ != _MISSING_VALUE else [],  # type: ignore[arg-type]
+        source_ref=source_ref,
+    )
+    if_stmt.set_generative_block("then", then)
+    if callable(else_):
+        if_stmt.set_generative_block("else", else_)
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(if_stmt)
 
 
 def control(
     ctrl: Union[SymbolicExpr, QBit, QArray[QBit]],
-    stmt_block: Optional[Union[QCallable, Callable[[], None]]] = None,
-    operand: Optional[Union[QCallable, Callable[[], None]]] = None,
+    stmt_block: Union[QCallable, Callable[[], None]],
 ) -> None:
-    if operand is not None:
-        warnings.warn(
-            "Parameter 'operand' of function 'control' has been renamed to "
-            "'stmt_block'. Parameter 'operand' will be deprecated in a future "
-            "release.\nHint: Change `control(ctrl=..., operand=...)` to "
-            "`control(ctrl=..., stmt_block=...)` or `control(..., ...)`.",
-            category=DeprecationWarning,
-            stacklevel=2,
-        )
-        stmt_block = operand
-    if TYPE_CHECKING:
-        assert stmt_block is not None
     _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))
-    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-        Control(
-            expression=Expression(expr=str(ctrl)),
-            body=_operand_to_body(stmt_block, "stmt_block"),
-            source_ref=source_ref,
-        )
+    control_stmt = Control(
+        expression=Expression(expr=str(ctrl)),
+        body=_operand_to_body(stmt_block, "stmt_block"),
+        source_ref=source_ref,
     )
+    control_stmt.set_generative_block("body", stmt_block)
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(control_stmt)
 
 
 def inplace_add(
@@ -164,56 +137,22 @@ def inplace_xor(
     )
 
 
-@overload  # FIXME: Remove overloading (CAD-21932)
 def within_apply(
     within: Callable[[], None],
     apply: Callable[[], None],
 ) -> None:
-    pass
-
-
-@overload
-def within_apply(
-    within: Callable[[], List[None]],
-    apply: Callable[[], List[None]],
-) -> None:
-    pass
-
-
-def within_apply(  # type:ignore[misc]
-    within: Optional[Callable[[], None]] = None,
-    apply: Optional[Callable[[], None]] = None,
-    compute: Optional[Callable[[], None]] = None,
-    action: Optional[Callable[[], None]] = None,
-) -> None:
-    if compute is not None or action is not None:
-        warnings.warn(
-            "Parameters 'compute' and 'action' of function 'within_apply' have "
-            "been renamed to 'within' and 'apply' respectively. Parameters 'compute' "
-            "and 'action' will be deprecated in a future release.\nHint: Change "
-            "`within_apply(compute=..., action=...)` to "
-            "`within_apply(within=..., apply=...)` or `within_apply(..., ...)`.",
-            category=DeprecationWarning,
-            stacklevel=2,
-        )
-    if compute is not None:
-        within = compute
-    if action is not None:
-        apply = action
-    if TYPE_CHECKING:
-        assert within is not None
-        assert apply is not None
     _validate_operand(within)
     _validate_operand(apply)
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))
-    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-        WithinApply(
-            compute=_operand_to_body(within, "within"),
-            action=_operand_to_body(apply, "apply"),
-            source_ref=source_ref,
-        )
+    within_apply_stmt = WithinApply(
+        compute=_operand_to_body(within, "within"),
+        action=_operand_to_body(apply, "apply"),
+        source_ref=source_ref,
     )
+    within_apply_stmt.set_generative_block("within", within)
+    within_apply_stmt.set_generative_block("apply", apply)
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(within_apply_stmt)
 
 
 def repeat(count: Union[SymbolicExpr, int], iteration: Callable[[int], None]) -> None:
@@ -236,98 +175,52 @@ def repeat(count: Union[SymbolicExpr, int], iteration: Callable[[int], None]) ->
             "Argument 'iteration' to 'repeat' should be a callable that takes one integer argument."
         )
 
-    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-        Repeat(
-            iter_var=inspect.getfullargspec(iteration).args[0],
-            count=Expression(expr=str(count)),
-            body=iteration_operand.body,
-            source_ref=source_ref,
-        )
+    repeat_stmt = Repeat(
+        iter_var=inspect.getfullargspec(iteration).args[0],
+        count=Expression(expr=str(count)),
+        body=iteration_operand.body,
+        source_ref=source_ref,
     )
+    repeat_stmt.set_generative_block("body", iteration)
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(repeat_stmt)
 
 
-@overload  # FIXME: Remove overloading (CAD-21932)
-def power(
-    exponent: SymbolicExpr,
-    stmt_block: Union[QCallable, Callable[[], None]],
-) -> None:
-    pass
-
-
-@overload
 def power(
-    exponent: int,
+    exponent: Union[SymbolicExpr, int],
     stmt_block: Union[QCallable, Callable[[], None]],
 ) -> None:
-    pass
-
-
-def power(
-    exponent: Optional[Union[SymbolicExpr, int]] = None,
-    stmt_block: Optional[Union[QCallable, Callable[[], None]]] = None,
-    power: Optional[Union[SymbolicExpr, int]] = None,
-    operand: Optional[Union[QCallable, Callable[[], None]]] = None,
-) -> None:
-    if power is not None or operand is not None:
-        warnings.warn(
-            "Parameters 'exponent' and 'operand' of function 'power' have been "
-            "renamed to 'exponent' and 'stmt_block' respectively. Parameters "
-            "'exponent' and 'operand' will be deprecated in a future release.\nHint: "
-            "Change `power(power=..., operand=...)` to "
-            "`power(exponent=..., stmt_block=...)` or `power(..., ...)`.",
-            category=DeprecationWarning,
-            stacklevel=2,
-        )
-    if power is not None:
-        exponent = power
-    if operand is not None:
-        stmt_block = operand
-    if TYPE_CHECKING:
-        assert exponent is not None
-        assert stmt_block is not None
     _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))
-    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-        Power(
-            power=Expression(expr=str(exponent)),
-            body=_operand_to_body(stmt_block, "stmt_block"),
-            source_ref=source_ref,
-        )
+    power_stmt = Power(
+        power=Expression(expr=str(exponent)),
+        body=_operand_to_body(stmt_block, "stmt_block"),
+        source_ref=source_ref,
     )
+    power_stmt.set_generative_block("body", stmt_block)
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(power_stmt)
 
 
-@overload  # FIXME: Remove overloading (CAD-21932)
-def invert(stmt_block: QCallable) -> None:
-    pass
-
-
-@overload
-def invert(stmt_block: Callable[[], None]) -> None:
-    pass
+def invert(stmt_block: Union[QCallable, Callable[[], None]]) -> None:
+    _validate_operand(stmt_block)
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
+    invert_stmt = Invert(
+        body=_operand_to_body(stmt_block, "stmt_block"), source_ref=source_ref
+    )
+    invert_stmt.set_generative_block("body", stmt_block)
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(invert_stmt)
 
 
-def invert(
-    stmt_block: Optional[Union[QCallable, Callable[[], None]]] = None,
-    operand: Optional[Union[QCallable, Callable[[], None]]] = None,
-) -> None:
-    if operand is not None:
-        warnings.warn(
-            "Parameter 'operand' of function 'invert' has been renamed to "
-            "'stmt_block'. Parameter 'operand' will be deprecated in a future "
-            "release.\nHint: Change `invert(operand=...)` to `invert(stmt_block=...)` "
-            "or `invert(...)`.",
-            category=DeprecationWarning,
-            stacklevel=2,
-        )
-        stmt_block = operand
-    if TYPE_CHECKING:
-        assert stmt_block is not None
-    _validate_operand(stmt_block)
+def phase(expr: SymbolicExpr, theta: float = 1.0) -> None:
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-        Invert(body=_operand_to_body(stmt_block, "stmt_block"), source_ref=source_ref)
+        PhaseOperation(
+            expression=Expression(expr=str(expr)),
+            theta=Expression(expr=str(theta)),
+            source_ref=source_ref,
+        )
     )
 
 
@@ -414,6 +307,7 @@ __all__ = [
     "power",
     "within_apply",
     "repeat",
+    "phase",
 ]
 
 

classiq/qmod/create_model_function.py

@@ -174,7 +174,7 @@ def _interpret_generative_model(
         gen_model,
         {gen_func.func_decl.name: gen_func.func_decl for gen_func in gen_functions},
     )
-    interpreter = Interpreter(gen_model, gen_functions)
+    interpreter = Interpreter(gen_model, gen_functions, is_frontend=True)
     set_frontend_interpreter(interpreter)
     functions_dict = nameables_to_dict(interpreter.expand().functions)
 

classiq/qmod/generative.py

@@ -1,7 +1,8 @@
 from contextlib import contextmanager
-from typing import TYPE_CHECKING, Iterator, Optional
+from typing import TYPE_CHECKING, Any, Iterator, Optional
 
 from classiq.interface.exceptions import ClassiqError
+from classiq.interface.generator.expressions.expression import Expression
 
 if TYPE_CHECKING:
     from classiq.model_expansions.interpreter import Interpreter
@@ -20,8 +21,10 @@ def generative_mode_context(generative: bool) -> Iterator[None]:
     global _GENERATIVE_MODE
     previous = _GENERATIVE_MODE
     _GENERATIVE_MODE = generative
-    yield
-    _GENERATIVE_MODE = previous
+    try:
+        yield
+    finally:
+        _GENERATIVE_MODE = previous
 
 
 @contextmanager
@@ -29,8 +32,10 @@ def enable_generative_expansion(enabled: bool) -> Iterator[None]:
     global _GENERATIVE_ENABLED_SWITCH
     previous = _GENERATIVE_ENABLED_SWITCH
     _GENERATIVE_ENABLED_SWITCH = enabled
-    yield
-    _GENERATIVE_ENABLED_SWITCH = previous
+    try:
+        yield
+    finally:
+        _GENERATIVE_ENABLED_SWITCH = previous
 
 
 def is_generative_expansion_enabled() -> bool:
@@ -46,3 +51,7 @@ def get_frontend_interpreter() -> "Interpreter":
     if _FRONTEND_INTERPRETER is None:
         raise ClassiqError("Interpreter was not set")
     return _FRONTEND_INTERPRETER
+
+
+def interpret_expression(expr: str) -> Any:
+    return get_frontend_interpreter().evaluate(Expression(expr=expr)).value

classiq/qmod/native/pretty_printer.py

@@ -37,6 +37,7 @@ from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperat
 from classiq.interface.model.invert import Invert
 from classiq.interface.model.model import Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.port_declaration import (
     AnonPortDeclaration,
 )
@@ -46,6 +47,7 @@ from classiq.interface.model.quantum_expressions.amplitude_loading_operation imp
 )
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
+    ArithmeticOperationKind,
 )
 from classiq.interface.model.quantum_function_call import (
     OperandIdentifier,
@@ -185,13 +187,11 @@ class DSLPrettyPrinter(Visitor):
     def visit_QuantumNumeric(self, qtype: QuantumNumeric) -> str:
         params = ""
         if qtype.size is not None:
-            assert qtype.is_signed is not None
-            assert qtype.fraction_digits is not None
-
             params = "<{}>".format(
                 ", ".join(
                     self.visit(param)
                     for param in [qtype.size, qtype.is_signed, qtype.fraction_digits]
+                    if param is not None
                 )
             )
 
@@ -255,6 +255,11 @@ class DSLPrettyPrinter(Visitor):
         control += f"{self._indent}}}\n"
         return control
 
+    def visit_PhaseOperation(self, op: PhaseOperation) -> str:
+        theta = f", {self.visit(op.theta)}" if op.theta else ""
+        phase = f"{self._indent}phase ({self.visit(op.expression)}{theta});\n"
+        return phase
+
     def visit_ClassicalIf(self, op: ClassicalIf) -> str:
         classical_if = f"{self._indent}if ({self.visit(op.condition)}) {{\n"
         if not op.then:
@@ -340,7 +345,12 @@ class DSLPrettyPrinter(Visitor):
         return f"{self.visit(var_ref.base_handle)}.{self.visit(var_ref.field)}"
 
     def visit_ArithmeticOperation(self, arith_op: ArithmeticOperation) -> str:
-        op = "^=" if arith_op.inplace_result else "="
+        if arith_op.get_operation_kind() == ArithmeticOperationKind.Assignment:
+            op = "="
+        elif arith_op.get_operation_kind() == ArithmeticOperationKind.InplaceXor:
+            op = "^="
+        else:
+            op = "+="
         return f"{self._indent}{self.visit(arith_op.result_var)} {op} {self.visit(arith_op.expression)};\n"
 
     def visit_AmplitudeLoadingOperation(

classiq/qmod/pretty_print/pretty_printer.py

@@ -39,6 +39,7 @@ from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperat
 from classiq.interface.model.invert import Invert
 from classiq.interface.model.model import Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.power import Power
 from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
@@ -46,6 +47,7 @@ from classiq.interface.model.quantum_expressions.amplitude_loading_operation imp
 )
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
+    ArithmeticOperationKind,
 )
 from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumAssignmentOperation,
@@ -114,12 +116,10 @@ class VariableDeclarationAssignment(Visitor):
 
         params = []
         if qtype.size is not None:
-            assert qtype.is_signed is not None
-            assert qtype.fraction_digits is not None
-
             params = [
                 self.pretty_printer.visit(param)
                 for param in [qtype.size, qtype.is_signed, qtype.fraction_digits]
+                if param is not None
             ]
 
         return "QNum", params
@@ -392,6 +392,11 @@ class PythonPrettyPrinter(Visitor):
         self._imports["control"] = 1
         return f"{self._indent}control({self.visit(op.expression)}, {self._visit_body(op.body)})\n"
 
+    def visit_PhaseOperation(self, op: PhaseOperation) -> str:
+        self._imports["phase"] = 1
+        theta = f", {self.visit(op.theta)}" if op.theta is not None else ""
+        return f"{self._indent}phase({self.visit(op.expression)},{theta})\n"
+
     def visit_ClassicalIf(self, op: ClassicalIf) -> str:
         self._imports["if_"] = 1
         return f"{self._indent}if_(condition={self.visit(op.condition)}, then={self._visit_body(op.then)}, else_={self._visit_body(op.else_)})\n"
@@ -464,7 +469,12 @@ class PythonPrettyPrinter(Visitor):
         return f"{self.visit(var_ref.base_handle)}.{self.visit(var_ref.field)}"
 
     def visit_ArithmeticOperation(self, arith_op: ArithmeticOperation) -> str:
-        op = "^=" if arith_op.inplace_result else "|="
+        if arith_op.get_operation_kind() == ArithmeticOperationKind.Assignment:
+            op = "|="
+        elif arith_op.get_operation_kind() == ArithmeticOperationKind.InplaceXor:
+            op = "^="
+        else:
+            op = "+="
         return f"{self._indent}{self.visit(arith_op.result_var)} {op} {self.visit(arith_op.expression)}\n"
 
     def visit_AmplitudeLoadingOperation(

classiq/qmod/qmod_constant.py

@@ -16,11 +16,16 @@ from classiq.qmod.qmod_parameter import CParam, CParamList, CParamStruct
 from classiq.qmod.symbolic_expr import SymbolicExpr
 from classiq.qmod.utilities import qmod_val_to_expr_str
 
+QMODULE_ERROR_MESSAGE = (
+    "Error trying to add a constant to a model without a current QModule."
+)
+
 
 class QConstant(SymbolicExpr):
     CURRENT_QMODULE: Optional[ModelStateContainer] = None
 
     def __init__(self, name: str, py_type: type, value: Any) -> None:
+        super().__init__(name, False)
         self.name = name
         self._py_type = py_type
         self._value = value
@@ -30,10 +35,12 @@ class QConstant(SymbolicExpr):
         QConstant.CURRENT_QMODULE = qmodule
 
     def add_to_model(self) -> None:
+        from classiq.qmod.builtins.constants import __all__ as builtin_constants
+
+        if self.name in builtin_constants:
+            return
         if QConstant.CURRENT_QMODULE is None:
-            raise ClassiqError(
-                "Error trying to add a constant to a model without a current QModule."
-            )
+            raise ClassiqError(QMODULE_ERROR_MESSAGE)
 
         expr = qmod_val_to_expr_str(self._value)
         if (
@@ -42,26 +49,32 @@ class QConstant(SymbolicExpr):
         ):
             raise ClassiqError(f"Constant {self.name} is already defined in the model")
 
+        QConstant.CURRENT_QMODULE.constants[self.name] = self._get_constant_node()
+
+    def _get_constant_node(self) -> Constant:
         if isinstance(self._value, QConstant):
-            QConstant.CURRENT_QMODULE.constants[self.name] = Constant(
+            if QConstant.CURRENT_QMODULE is None:
+                raise ClassiqError(QMODULE_ERROR_MESSAGE)
+            return Constant(
                 name=self.name,
                 const_type=QConstant.CURRENT_QMODULE.constants[
                     self._value.name
                 ].const_type,
                 value=Expression(expr=self._value.name),
             )
-        else:
-            qmod_type = python_type_to_qmod(
-                self._py_type, qmodule=QConstant.CURRENT_QMODULE
-            )
-            if qmod_type is None:
-                raise ClassiqError("Invalid QMOD type")
 
-            QConstant.CURRENT_QMODULE.constants[self.name] = Constant(
-                name=self.name,
-                const_type=qmod_type,
-                value=Expression(expr=expr),
-            )
+        qmod_type = python_type_to_qmod(
+            self._py_type, qmodule=QConstant.CURRENT_QMODULE
+        )
+        if qmod_type is None:
+            raise ClassiqError("Invalid QMOD type")
+
+        expr = qmod_val_to_expr_str(self._value)
+        return Constant(
+            name=self.name,
+            const_type=qmod_type,
+            value=Expression(expr=expr),
+        )
 
     def __getattr__(self, name: str) -> CParam:
         self.add_to_model()
@@ -100,6 +113,3 @@ class QConstant(SymbolicExpr):
             qmod_type,
             QConstant.CURRENT_QMODULE,
         )[item]
-
-    def __str__(self) -> str:
-        return self.name