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

classiq/model_expansions/scope.py

@@ -1,11 +1,10 @@
 import itertools
 from collections import UserDict
+from contextlib import contextmanager
 from dataclasses import dataclass
 from functools import singledispatch
 from typing import TYPE_CHECKING, Any, Dict, Iterator, Optional, Type, TypeVar, Union
 
-from typing_extensions import Self
-
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
@@ -180,13 +179,13 @@ class Scope(EvaluatedUserDict):
         data: Optional[Dict[str, Evaluated]] = None,
         /,
         *,
-        parent: Optional[Self] = None,
+        parent: Optional["Scope"] = None,
     ) -> None:
         super().__init__(data or {})
-        self._parent: Optional[Self] = parent
+        self._parent: Optional["Scope"] = parent
 
     @property
-    def parent(self) -> Optional[Self]:
+    def parent(self) -> Optional["Scope"]:
         return self._parent
 
     def __getitem__(self, name: str) -> Evaluated:
@@ -224,3 +223,15 @@ class Scope(EvaluatedUserDict):
             (self.data or {}) | (other.data or {}),
             parent=parent,
         )
+
+    def _copy(self) -> "Scope":
+        return Scope(
+            self.data, parent=None if self._parent is None else self._parent.copy()
+        )
+
+    @contextmanager
+    def freeze(self) -> Iterator[None]:
+        previous = self._copy()
+        yield
+        self.data = previous.data
+        self._parent = previous._parent

classiq/model_expansions/scope_initialization.py

@@ -1,5 +1,6 @@
 from typing import List, Sequence
 
+from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression_constants import (
     CPARAM_EXECUTION_SUFFIX,
@@ -22,6 +23,7 @@ from classiq.model_expansions.evaluators.parameter_types import (
 )
 from classiq.model_expansions.expression_renamer import ExpressionRenamer
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+from classiq.qmod.builtins import BUILTIN_CONSTANTS
 from classiq.qmod.builtins.functions import (
     CORE_LIB_DECLS,
     OPEN_LIB_DECLS,
@@ -71,7 +73,7 @@ def _add_generative_functions_to_scope(
                 name=function.func_decl.name,
                 positional_arg_declarations=function.func_decl.positional_arg_declarations,
                 scope=Scope(parent=scope),
-                generative_function=function,
+                generative_blocks={"body": function},
             )
         )
 
@@ -104,6 +106,14 @@ def _init_builtins_scope(scope: Scope) -> None:
                     is_atomic=True,
                 )
             )
+    for constant in BUILTIN_CONSTANTS:
+        value = constant.value
+        if not value.is_evaluated():
+            raise ClassiqError(
+                f"Unevaluated built-in constants not supported. Offending constant: "
+                f"{constant.name} = {value}"
+            )
+        scope[constant.name] = Evaluated(value=value.value.value)
 
 
 def add_entry_point_params_to_scope(

classiq/model_expansions/sympy_conversion/expression_to_sympy.py

@@ -1,5 +1,5 @@
 import ast
-from typing import TYPE_CHECKING, Dict, Type
+from typing import TYPE_CHECKING, Dict, Type, cast
 
 from classiq.interface.exceptions import ClassiqExpansionError
 
@@ -116,6 +116,9 @@ class ExpressionSympyTranslator(ast.NodeTransformer):
         return self.generic_visit(node)
 
     def visit_Call(self, node: ast.Call) -> ast.AST:
+        if isinstance(node.func, ast.Name) and node.func.id == "Piecewise":
+            return self._visit_piecewise(node)
+
         if (
             not isinstance(node.func, ast.Name)
             or node.func.id not in self.SPECIAL_FUNCTIONS
@@ -128,6 +131,25 @@ class ExpressionSympyTranslator(ast.NodeTransformer):
             keywords=[self.visit(arg) for arg in node.keywords],
         )
 
+    def _visit_piecewise(self, node: ast.Call) -> ast.AST:
+        # sympy Piecewise expression may include bitwise operations:
+        # Piecewise((0, Eq(x, 0)), (0.5, Eq(x, 1) | Eq(x, 2)), (1, True))
+        #                                         ^
+        # We should avoid converting these to 'BitwiseOr' and such.
+        return ast.Call(
+            func=node.func,
+            args=[
+                ast.Tuple(
+                    elts=(
+                        self.generic_visit(cast(ast.Tuple, arg).elts[0]),
+                        cast(ast.Tuple, arg).elts[1],
+                    )
+                )
+                for arg in node.args
+            ],
+            keywords=node.keywords,
+        )
+
     def visit_Subscript(self, node: ast.Subscript) -> ast.AST:
         if isinstance(node.slice, ast.Slice):
             if node.slice.lower is not None:

classiq/model_expansions/visitors/variable_references.py

@@ -1,6 +1,6 @@
 import ast
 from contextlib import contextmanager
-from typing import Dict, Iterator, Optional, Set, Union
+from typing import Dict, Iterator, List, Optional, Union
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -23,10 +23,14 @@ from classiq.interface.model.handle_binding import (
 
 class VarRefCollector(ast.NodeVisitor):
     def __init__(self, ignore_duplicated_handles: bool = False) -> None:
-        self.var_handles: Set[HandleBinding] = set()
+        self._var_handles: Dict[HandleBinding, bool] = {}
         self._ignore_duplicated_handles = ignore_duplicated_handles
         self._is_nested = False
 
+    @property
+    def var_handles(self) -> List[HandleBinding]:
+        return list(self._var_handles)
+
     def visit(self, node: ast.AST) -> Union[
         SubscriptHandleBinding,
         SlicedHandleBinding,
@@ -35,8 +39,8 @@ class VarRefCollector(ast.NodeVisitor):
         None,
     ]:
         res = super().visit(node)
-        if not self._ignore_duplicated_handles and len(self.var_handles) != len(
-            {handle.name for handle in self.var_handles}
+        if not self._ignore_duplicated_handles and len(self._var_handles) != len(
+            {handle.name for handle in self._var_handles}
         ):
             raise ClassiqExpansionError(
                 "Multiple non-identical variable references in an expression are not supported."
@@ -71,7 +75,7 @@ class VarRefCollector(ast.NodeVisitor):
             raise ClassiqInternalExpansionError("Unevaluated slice.")
 
         if not self._is_nested:
-            self.var_handles.add(handle)
+            self._var_handles[handle] = True
         return handle
 
     def visit_Attribute(self, node: ast.Attribute) -> Optional[FieldHandleBinding]:
@@ -84,7 +88,7 @@ class VarRefCollector(ast.NodeVisitor):
             field=node.attr,
         )
         if not self._is_nested:
-            self.var_handles.add(handle)
+            self._var_handles[handle] = True
         return handle
 
     def visit_Name(self, node: ast.Name) -> Optional[HandleBinding]:
@@ -94,7 +98,7 @@ class VarRefCollector(ast.NodeVisitor):
             return None
         handle = HandleBinding(name=node.id)
         if not self._is_nested:
-            self.var_handles.add(handle)
+            self._var_handles[handle] = True
         return handle
 
     @contextmanager

classiq/qmod/builtins/__init__.py

@@ -6,6 +6,8 @@ from .classical_execution_primitives import (
 )
 from .classical_functions import *  # noqa: F403
 from .classical_functions import __all__ as _builtin_classical_functions
+from .constants import *  # noqa: F403
+from .constants import __all__ as _builtin_constants
 from .enums import *  # noqa: F403
 from .enums import __all__ as _builtin_enums
 from .functions import *  # noqa: F403
@@ -18,6 +20,13 @@ from .structs import __all__ as _builtin_structs
 FinanceFunctionInput.update_forward_refs(
     FinanceFunctionType=FinanceFunctionType  # noqa: F405
 )
+BUILTIN_CONSTANTS = [
+    constant._get_constant_node()
+    for constant in [
+        SIGNED,  # noqa: F405
+        UNSIGNED,  # noqa: F405
+    ]
+]
 
 __all__ = (
     _builtin_enums
@@ -26,4 +35,5 @@ __all__ = (
     + _builtin_operations
     + _builtin_classical_execution_primitives
     + _builtin_classical_functions
+    + _builtin_constants
 )

classiq/qmod/builtins/constants.py

@@ -0,0 +1,10 @@
+from classiq.qmod.cparam import CBool
+from classiq.qmod.qmod_constant import QConstant
+
+SIGNED = QConstant("SIGNED", CBool, True)
+UNSIGNED = QConstant("UNSIGNED", CBool, False)
+
+__all__ = [
+    "SIGNED",
+    "UNSIGNED",
+]

classiq/qmod/builtins/functions/state_preparation.py

@@ -340,7 +340,10 @@ def inplace_prepare_int(value: CInt, target: QArray[QBit]) -> None:
 
 
 @qfunc(external=True)
-def prepare_int(value: CInt, out: Output[QNum]) -> None:
+def prepare_int(
+    value: CInt,
+    out: Output[QNum[Literal["floor(log(value, 2)) + 1"], Literal[False], Literal[0]]],
+) -> None:
     """
     [Qmod Classiq-library function]
 

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
@@ -80,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(
@@ -165,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:
@@ -237,99 +175,41 @@ 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,
+    exponent: Union[SymbolicExpr, int],
     stmt_block: Union[QCallable, Callable[[], None]],
 ) -> None:
-    pass
-
-
-@overload
-def power(
-    exponent: 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: 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
+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))
-    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-        Invert(body=_operand_to_body(stmt_block, "stmt_block"), source_ref=source_ref)
+    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 phase(expr: SymbolicExpr, theta: float = 1.0) -> None:

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

@@ -47,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,
@@ -186,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
                 )
             )
 
@@ -258,7 +257,7 @@ class DSLPrettyPrinter(Visitor):
 
     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"
+        phase = f"{self._indent}phase ({self.visit(op.expression)}{theta});\n"
         return phase
 
     def visit_ClassicalIf(self, op: ClassicalIf) -> str:
@@ -346,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

@@ -47,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,
@@ -115,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
@@ -470,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(