classiq 0.53.0__py3-none-any.whl → 0.55.0__py3-none-any.whl

classiq/qmod/classical_function.py

@@ -1,8 +1,7 @@
 import ast
 import inspect
-import sys
 from textwrap import dedent
-from typing import Any, Callable, Dict
+from typing import Any, Callable
 
 from classiq.interface.exceptions import ClassiqValueError
 
@@ -17,16 +16,13 @@ def _unparse_function_body(code: str, func: ast.FunctionDef) -> str:
 
 
 class CFunc:
-    def __init__(self, py_callable: Callable[[], None], caller_locals: Dict[str, Any]):
+    def __init__(self, py_callable: Callable[[], None], caller_locals: dict[str, Any]):
         code = dedent(inspect.getsource(py_callable))
         func = ast.parse(code).body[0]
         if not isinstance(func, ast.FunctionDef):
             raise ClassiqValueError("Use @cfunc to decorate a function")
         if len(func.args.args) > 0:
             raise ClassiqValueError("A @cfunc must receive no arguments")
-        if sys.version_info >= (3, 9):
-            self.code = "\n".join([ast.unparse(statement) for statement in func.body])
-        else:
-            self.code = _unparse_function_body(code, func)
+        self.code = "\n".join([ast.unparse(statement) for statement in func.body])
 
         self._caller_constants = caller_locals

classiq/qmod/create_model_function.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Dict, List, Optional, Union, cast
+from typing import TYPE_CHECKING, Optional, Union, cast
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
@@ -60,6 +60,7 @@ def create_model(
     user_gen_functions = {
         gen_func._py_callable.__name__ for gen_func in GEN_QFUNCS
     } - set(BUILTIN_FUNCTION_DECLARATIONS.keys())
+
     if len(user_gen_functions) > 0 and is_generative_expansion_enabled():
         model = _expand_generative_model(
             (
@@ -100,11 +101,17 @@ def _expand_generative_model(
     def _dummy() -> None:
         pass
 
+    functions_compilation_metadata = {
+        dec_func._py_callable.__name__: dec_func.compilation_metadata
+        for dec_func in DEC_QFUNCS
+        if dec_func.compilation_metadata is not None
+    }
     model = _dummy.create_model(
         constraints,
         execution_preferences,
         preferences,
         classical_execution_function,
+        functions_compilation_metadata,
     )
     generative_functions = _get_generative_functions(gen_main, preferences)
     model.functions = generative_functions
@@ -116,7 +123,7 @@ def _expand_generative_model(
 
 def _get_generative_functions(
     gen_main: QFunc, preferences: Optional[Preferences]
-) -> List[NativeFunctionDefinition]:
+) -> list[NativeFunctionDefinition]:
     # The Interpreter accepts a model and a list of generative functions.
     # Since the main function is generative, it can only be expanded using the
     # Interpreter.
@@ -154,10 +161,11 @@ def _get_wrapper_main(gen_main: QFunc, preferences: Optional[Preferences]) -> Mo
     )
 
 
-def _get_all_model_functions_as_generative_functions() -> List[GenerativeQFunc]:
+def _get_all_model_functions_as_generative_functions() -> list[GenerativeQFunc]:
 
     gen_functions = list(GEN_QFUNCS) + [
-        _get_gen_from_dec(dec_func) for dec_func in DEC_QFUNCS
+        GenerativeQFunc(dec_func._py_callable, dec_func.func_decl)
+        for dec_func in DEC_QFUNCS
     ]
     return [
         (
@@ -173,26 +181,17 @@ def _get_all_model_functions_as_generative_functions() -> List[GenerativeQFunc]:
     ]
 
 
-def _get_gen_from_dec(dec_func: QFunc) -> GenerativeQFunc:
-    synthesis_data = dec_func.synthesis_data
-    if synthesis_data is not None and synthesis_data.should_synthesize_separately:
-        raise ClassiqError(
-            """The model contains generative functions,
-            which cannot coexist with functions marked for separate synthesis"""
-        )
-    return GenerativeQFunc(dec_func._py_callable, dec_func.func_decl)
-
-
 def _interpret_generative_model(
-    gen_model: Model, gen_functions: List[GenerativeQFunc]
-) -> Dict[str, NativeFunctionDefinition]:
+    gen_model: Model, gen_functions: list[GenerativeQFunc]
+) -> dict[str, NativeFunctionDefinition]:
     resolve_function_calls(
         gen_model,
         {gen_func.func_decl.name: gen_func.func_decl for gen_func in gen_functions},
     )
     interpreter = Interpreter(gen_model, gen_functions, is_frontend=True)
     set_frontend_interpreter(interpreter)
-    functions_dict = nameables_to_dict(interpreter.expand().functions)
+    expand_model = interpreter.expand()
+    functions_dict = nameables_to_dict(expand_model.functions)
 
     # Inline _gen_main call in main
     expanded_gen_main_name = cast(

classiq/qmod/declaration_inferrer.py

@@ -1,15 +1,12 @@
 import dataclasses
 import sys
+from collections.abc import Sequence
 from enum import EnumMeta
 from typing import (
     Any,
     Callable,
-    List,
     Literal,
     Optional,
-    Sequence,
-    Tuple,
-    Type,
     get_args,
     get_origin,
     overload,
@@ -91,7 +88,7 @@ def python_type_to_qmod(
 
 def _extract_port_decl(name: Optional[str], py_type: Any) -> AnonPortDeclaration:
     # FIXME: CAD-13409
-    qtype: Type[QVar] = QVar.from_type_hint(py_type)  # type:ignore[assignment]
+    qtype: type[QVar] = QVar.from_type_hint(py_type)  # type:ignore[assignment]
     direction = qtype.port_direction(py_type)
     if isinstance(py_type, _AnnotatedAlias):
         py_type = py_type.__args__[0]
@@ -128,7 +125,7 @@ def _extract_operand_decl(
     return param
 
 
-def _extract_operand_param(py_type: Any) -> Tuple[Optional[str], Any]:
+def _extract_operand_param(py_type: Any) -> tuple[Optional[str], Any]:
     if sys.version_info[0:2] < (3, 9) or get_origin(py_type) is not Annotated:
         return None, py_type
     args = get_args(py_type)
@@ -152,22 +149,22 @@ def _extract_operand_param(py_type: Any) -> Tuple[Optional[str], Any]:
 
 @overload
 def _extract_positional_args(
-    args: Sequence[Tuple[str, Any]], qmodule: Optional[ModelStateContainer]
+    args: Sequence[tuple[str, Any]], qmodule: Optional[ModelStateContainer]
 ) -> Sequence[PositionalArg]:
     pass
 
 
 @overload
 def _extract_positional_args(
-    args: Sequence[Tuple[Optional[str], Any]], qmodule: Optional[ModelStateContainer]
+    args: Sequence[tuple[Optional[str], Any]], qmodule: Optional[ModelStateContainer]
 ) -> Sequence[AnonPositionalArg]:
     pass
 
 
 def _extract_positional_args(
-    args: Sequence[Tuple[Optional[str], Any]], qmodule: Optional[ModelStateContainer]
+    args: Sequence[tuple[Optional[str], Any]], qmodule: Optional[ModelStateContainer]
 ) -> Sequence[AnonPositionalArg]:
-    result: List[AnonPositionalArg] = []
+    result: list[AnonPositionalArg] = []
     for name, py_type in args:
         if name == "return":
             continue

classiq/qmod/expression_query.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, List, Tuple
+from typing import TYPE_CHECKING
 
 from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
 from classiq.interface.generator.arith.number_utils import MAXIMAL_MACHINE_PRECISION
@@ -9,10 +9,10 @@ from classiq.qmod.symbolic_type import SymbolicTypes
 
 
 def get_expression_numeric_attributes(
-    vars: List[QNum],
+    vars: list[QNum],
     expr: SymbolicTypes,
     machine_precision: int = MAXIMAL_MACHINE_PRECISION,
-) -> Tuple[int, bool, int]:
+) -> tuple[int, bool, int]:
     """
     Computes and returns the numeric attributes of a given symbolic expression.
 

classiq/qmod/generative.py

@@ -1,5 +1,6 @@
+from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import TYPE_CHECKING, Any, Iterator, Optional
+from typing import TYPE_CHECKING, Any, Optional
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.expressions.expression import Expression

classiq/qmod/model_state_container.py

@@ -1,18 +1,20 @@
-from typing import Dict
-
 from classiq.interface.generator.constant import Constant
+from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
-from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.native_function_definition import (
+    NativeFunctionDefinition,
+)
 
 
 class ModelStateContainer:
-    enum_decls: Dict[str, EnumDeclaration]
-    type_decls: Dict[str, StructDeclaration]
-    qstruct_decls: Dict[str, QStructDeclaration]
-    native_defs: Dict[str, NativeFunctionDefinition]
-    constants: Dict[str, Constant]
+    enum_decls: dict[str, EnumDeclaration]
+    type_decls: dict[str, StructDeclaration]
+    qstruct_decls: dict[str, QStructDeclaration]
+    native_defs: dict[str, NativeFunctionDefinition]
+    constants: dict[str, Constant]
+    functions_compilation_metadata: dict[str, CompilationMetadata]
 
 
 QMODULE = ModelStateContainer()

classiq/qmod/native/__init__.py

@@ -1,9 +1,7 @@
-from typing import List
-
 from .pretty_printer import DSLPrettyPrinter
 
 __all__ = ["DSLPrettyPrinter"]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/qmod/native/expression_to_qmod.py

@@ -1,14 +1,15 @@
 import ast
 import re
+from collections.abc import Mapping
 from dataclasses import dataclass
-from typing import Callable, Dict, List, Mapping, Optional, Type
+from typing import Callable, Optional
 
 import numpy as np
 
 from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 IDENTIFIER = re.compile(r"[a-zA-Z_]\w*")
-BINARY_OPS: Mapping[Type[ast.operator], str] = {
+BINARY_OPS: Mapping[type[ast.operator], str] = {
     ast.Add: "+",
     ast.Sub: "-",
     ast.Mult: "*",
@@ -21,14 +22,14 @@ BINARY_OPS: Mapping[Type[ast.operator], str] = {
     ast.LShift: "<<",
     ast.RShift: ">>",
 }
-BOOL_OPS: Mapping[Type[ast.boolop], str] = {ast.And: "and", ast.Or: "or"}
-UNARY_OPS: Mapping[Type[ast.unaryop], str] = {
+BOOL_OPS: Mapping[type[ast.boolop], str] = {ast.And: "and", ast.Or: "or"}
+UNARY_OPS: Mapping[type[ast.unaryop], str] = {
     ast.UAdd: "+",
     ast.USub: "-",
     ast.Invert: "~",
     ast.Not: "not",
 }
-COMPARE_OPS: Mapping[Type[ast.cmpop], str] = {
+COMPARE_OPS: Mapping[type[ast.cmpop], str] = {
     ast.Eq: "==",
     ast.NotEq: "!=",
     ast.Lt: "<",
@@ -139,7 +140,7 @@ class ASTToQMODCode:
         else:
             raise AssertionError("Error parsing expression: unsupported AST node.")
 
-    def indent_items(self, items: Callable[[], List[str]]) -> str:
+    def indent_items(self, items: Callable[[], list[str]]) -> str:
         should_indent = (
             len("".join([i.strip() for i in items()])) >= LIST_FORMAT_CHAR_LIMIT
         )
@@ -165,8 +166,8 @@ class ASTToQMODCode:
 def _remove_redundant_parentheses(expr: str) -> str:
     if not (expr.startswith("(") and expr.endswith(")")):
         return expr
-    parentheses_map: Dict[int, int] = dict()
-    stack: List[int] = []
+    parentheses_map: dict[int, int] = dict()
+    stack: list[int] = []
     for index, char in enumerate(expr):
         if char == "(":
             stack.append(index)

classiq/qmod/native/pretty_printer.py

@@ -1,4 +1,5 @@
-from typing import Dict, List, Mapping, Optional, Union
+from collections.abc import Mapping
+from typing import Optional, Union
 
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
@@ -135,7 +136,7 @@ class DSLPrettyPrinter(Visitor):
     def visit_EnumDeclaration(self, enum_decl: EnumDeclaration) -> str:
         return f"enum {enum_decl.name} {{\n{self._visit_members(enum_decl.members)}}}\n"
 
-    def _visit_members(self, members: Dict[str, int]) -> str:
+    def _visit_members(self, members: dict[str, int]) -> str:
         self._level += 1
         members_str = "".join(
             f"{self._indent}{self.visit(member_name)} = {member_value};\n"
@@ -252,7 +253,12 @@ class DSLPrettyPrinter(Visitor):
     def visit_Control(self, op: Control) -> str:
         control = f"{self._indent}control ({self.visit(op.expression)}) {{\n"
         control += self._visit_body(op.body)
-        control += f"{self._indent}}}\n"
+        control += f"{self._indent}}}"
+        if op.else_block is not None:
+            control += " else {\n"
+            control += self._visit_body(op.else_block)
+            control += f"{self._indent}}}"
+        control += "\n"
         return control
 
     def visit_PhaseOperation(self, op: PhaseOperation) -> str:
@@ -310,7 +316,7 @@ class DSLPrettyPrinter(Visitor):
     def visit_InplaceBinaryOperation(self, op: InplaceBinaryOperation) -> str:
         return f"{self._indent}{op.operation.value}({self.visit(op.value)}, {self.visit(op.target)});\n"
 
-    def _visit_pack_expr(self, vars: List[HandleBinding]) -> str:
+    def _visit_pack_expr(self, vars: list[HandleBinding]) -> str:
         if len(vars) == 1:
             return self.visit(vars[0])
 
@@ -324,7 +330,7 @@ class DSLPrettyPrinter(Visitor):
 
     def visit_QuantumLambdaFunction(self, qlambda: QuantumLambdaFunction) -> str:
         positional_args = ", ".join(
-            qlambda.get_rename_params()[idx]
+            qlambda.pos_rename_params[idx]
             for idx, arg_decl in enumerate(
                 qlambda.func_decl.positional_arg_declarations
             )
@@ -358,7 +364,7 @@ class DSLPrettyPrinter(Visitor):
     ) -> str:
         return f"{self._indent}{self.visit(amplitude_loading_op.result_var)} *= {self.visit(amplitude_loading_op.expression)};\n"
 
-    def _print_bind_handles(self, handles: List[HandleBinding]) -> str:
+    def _print_bind_handles(self, handles: list[HandleBinding]) -> str:
         if len(handles) == 1:
             return self.visit(handles[0])
 

classiq/qmod/pretty_print/__init__.py

@@ -1,9 +1,7 @@
-from typing import List
-
 from .pretty_printer import PythonPrettyPrinter
 
 __all__ = ["PythonPrettyPrinter"]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/qmod/pretty_print/expression_to_python.py

@@ -1,7 +1,8 @@
 import ast
 import re
+from collections.abc import Mapping
 from dataclasses import dataclass
-from typing import Callable, Dict, List, Mapping, Type
+from typing import Callable
 
 import numpy as np
 
@@ -9,7 +10,7 @@ import classiq
 from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 IDENTIFIER = re.compile(r"[a-zA-Z_]\w*")
-BINARY_OPS: Mapping[Type[ast.operator], str] = {
+BINARY_OPS: Mapping[type[ast.operator], str] = {
     ast.Add: "+",
     ast.Sub: "-",
     ast.Mult: "*",
@@ -22,14 +23,14 @@ BINARY_OPS: Mapping[Type[ast.operator], str] = {
     ast.LShift: "<<",
     ast.RShift: ">>",
 }
-BOOL_OPS: Mapping[Type[ast.boolop], str] = {ast.And: "and", ast.Or: "or"}
-UNARY_OPS: Mapping[Type[ast.unaryop], str] = {
+BOOL_OPS: Mapping[type[ast.boolop], str] = {ast.And: "and", ast.Or: "or"}
+UNARY_OPS: Mapping[type[ast.unaryop], str] = {
     ast.UAdd: "+",
     ast.USub: "-",
     ast.Invert: "~",
     ast.Not: "not",
 }
-COMPARE_OPS: Mapping[Type[ast.cmpop], str] = {
+COMPARE_OPS: Mapping[type[ast.cmpop], str] = {
     ast.Eq: "==",
     ast.NotEq: "!=",
     ast.Lt: "<",
@@ -43,8 +44,8 @@ LIST_FORMAT_CHAR_LIMIT = 20
 @dataclass
 class ASTToQMODCode(ast.NodeVisitor):
     level: int
-    imports: Dict[str, int]
-    symbolic_imports: Dict[str, int]
+    imports: dict[str, int]
+    symbolic_imports: dict[str, int]
     decimal_precision: int
     indent_seq: str = "    "
 
@@ -162,7 +163,7 @@ class ASTToQMODCode(ast.NodeVisitor):
     def generic_visit(self, node: ast.AST) -> None:
         raise AssertionError("Cannot parse node of type: " + type(node).__name__)
 
-    def indent_items(self, items: Callable[[], List[str]]) -> str:
+    def indent_items(self, items: Callable[[], list[str]]) -> str:
         should_indent = (
             len("".join([i.strip() for i in items()])) >= LIST_FORMAT_CHAR_LIMIT
         )
@@ -188,8 +189,8 @@ class ASTToQMODCode(ast.NodeVisitor):
 def _remove_redundant_parentheses(expr: str) -> str:
     if not (expr.startswith("(") and expr.endswith(")")):
         return expr
-    parentheses_map: Dict[int, int] = dict()
-    stack: List[int] = []
+    parentheses_map: dict[int, int] = dict()
+    stack: list[int] = []
     for index, char in enumerate(expr):
         if char == "(":
             stack.append(index)
@@ -208,8 +209,8 @@ def _remove_redundant_parentheses(expr: str) -> str:
 
 def transform_expression(
     expr: str,
-    imports: Dict[str, int],
-    symbolic_imports: Dict[str, int],
+    imports: dict[str, int],
+    symbolic_imports: dict[str, int],
     level: int = 0,
     decimal_precision: int = DEFAULT_DECIMAL_PRECISION,
 ) -> str:

classiq/qmod/pretty_print/pretty_printer.py

@@ -1,4 +1,5 @@
-from typing import Dict, List, Mapping, Optional, Tuple, Union, cast
+from collections.abc import Mapping
+from typing import Optional, Union, cast
 
 import black
 
@@ -49,9 +50,6 @@ from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
     ArithmeticOperationKind,
 )
-from classiq.interface.model.quantum_expressions.quantum_expression import (
-    QuantumAssignmentOperation,
-)
 from classiq.interface.model.quantum_function_call import (
     OperandIdentifier,
     QuantumFunctionCall,
@@ -88,20 +86,20 @@ class VariableDeclarationAssignment(Visitor):
     def __init__(self, pretty_printer: "PythonPrettyPrinter") -> None:
         self.pretty_printer = pretty_printer
 
-    def visit(self, node: NodeType) -> Tuple[str, Optional[List[str]]]:
+    def visit(self, node: NodeType) -> tuple[str, Optional[list[str]]]:
         res = super().visit(node)
         if not isinstance(res, tuple):
             raise AssertionError(f"Pretty printing for {type(node)} is not supported ")
         return res  # type: ignore[return-value]
 
-    def visit_QuantumBit(self, qtype: QuantumBit) -> Tuple[str, Optional[List[str]]]:
+    def visit_QuantumBit(self, qtype: QuantumBit) -> tuple[str, Optional[list[str]]]:
         self.pretty_printer._imports["QBit"] = 1
 
         return "QBit", None
 
     def visit_QuantumBitvector(
         self, qtype: QuantumBitvector
-    ) -> Tuple[str, Optional[List[str]]]:
+    ) -> tuple[str, Optional[list[str]]]:
         self.pretty_printer._imports["QArray"] = 1
 
         element_type = self.pretty_printer.visit(qtype.element_type)
@@ -111,7 +109,7 @@ class VariableDeclarationAssignment(Visitor):
 
     def visit_QuantumNumeric(
         self, qtype: QuantumNumeric
-    ) -> Tuple[str, Optional[List[str]]]:
+    ) -> tuple[str, Optional[list[str]]]:
         self.pretty_printer._imports["QNum"] = 1
 
         params = []
@@ -124,7 +122,7 @@ class VariableDeclarationAssignment(Visitor):
 
         return "QNum", params
 
-    def visit_TypeName(self, qtype: TypeName) -> Tuple[str, None]:
+    def visit_TypeName(self, qtype: TypeName) -> tuple[str, None]:
         return qtype.name, None
 
 
@@ -136,7 +134,7 @@ class PythonPrettyPrinter(Visitor):
         self._import_enum = False
         self._import_dataclass = False
         self._import_annotated = False
-        self._symbolic_imports: Dict[str, int] = dict()
+        self._symbolic_imports: dict[str, int] = dict()
         self._functions: Optional[Mapping[str, QuantumFunctionDeclaration]] = None
 
     def visit(self, node: NodeType) -> str:
@@ -183,7 +181,7 @@ class PythonPrettyPrinter(Visitor):
     def special_imports(self) -> str:
         imports = ""
         if self._import_annotated:
-            imports += "from typing_extensions import Annotated\n"
+            imports += "from typing import Annotated\n"
         if self._import_dataclass:
             imports += "from dataclasses import dataclass\n"
         if self._import_enum:
@@ -214,7 +212,7 @@ class PythonPrettyPrinter(Visitor):
         self._import_enum = True
         return f"class {enum_decl.name}(IntEnum):\n{self._visit_members(enum_decl.members)}\n"
 
-    def _visit_members(self, members: Dict[str, int]) -> str:
+    def _visit_members(self, members: dict[str, int]) -> str:
         self._level += 1
         members_str = "".join(
             f"{self._indent}{self.visit(member_name)} = {member_value}\n"
@@ -390,7 +388,10 @@ class PythonPrettyPrinter(Visitor):
 
     def visit_Control(self, op: Control) -> str:
         self._imports["control"] = 1
-        return f"{self._indent}control({self.visit(op.expression)}, {self._visit_body(op.body)})\n"
+        control_else = (
+            f", {self._visit_body(op.else_block)}" if op.else_block is not None else ""
+        )
+        return f"{self._indent}control({self.visit(op.expression)}, {self._visit_body(op.body)}{control_else})\n"
 
     def visit_PhaseOperation(self, op: PhaseOperation) -> str:
         self._imports["phase"] = 1
@@ -418,7 +419,7 @@ class PythonPrettyPrinter(Visitor):
         return f"{self._indent}invert({self._visit_body(invert.body)})\n"
 
     def _visit_body(
-        self, body: StatementBlock, operand_arguments: Optional[List[str]] = None
+        self, body: StatementBlock, operand_arguments: Optional[list[str]] = None
     ) -> str:
         if len(body) == 0:
             return "lambda: []"
@@ -428,13 +429,16 @@ class PythonPrettyPrinter(Visitor):
         code = f"lambda{argument_string}: {'[' if len(body) > 1 else ''}\n"
         self._level += 1
         for i, statement in enumerate(body):
-            if isinstance(
-                statement, (QuantumAssignmentOperation, VariableDeclarationStatement)
-            ):
+            if isinstance(statement, VariableDeclarationStatement):
                 raise AssertionError(
-                    "pretty printing quantum assignment operations or variable declaration statements in quantum lambda function is unsupported."
+                    "pretty printing variable declaration statements in quantum lambda function is unsupported."
                 )
-            code += self.visit(statement)
+            if isinstance(statement, AmplitudeLoadingOperation):
+                code += self.visit_AmplitudeLoadingOperation(statement, in_lambda=True)
+            elif isinstance(statement, ArithmeticOperation):
+                code += self.visit_ArithmeticOperation(statement, in_lambda=True)
+            else:
+                code += self.visit(statement)
             if i < len(body) - 1:
                 code += ","
         self._level -= 1
@@ -454,7 +458,7 @@ class PythonPrettyPrinter(Visitor):
         )
 
     def visit_QuantumLambdaFunction(self, qlambda: QuantumLambdaFunction) -> str:
-        return self._visit_body(qlambda.body, qlambda.get_rename_params())
+        return self._visit_body(qlambda.body, qlambda.pos_rename_params)
 
     def visit_HandleBinding(self, var_ref: HandleBinding) -> str:
         return var_ref.name
@@ -468,21 +472,32 @@ class PythonPrettyPrinter(Visitor):
     def visit_FieldHandleBinding(self, var_ref: FieldHandleBinding) -> str:
         return f"{self.visit(var_ref.base_handle)}.{self.visit(var_ref.field)}"
 
-    def visit_ArithmeticOperation(self, arith_op: ArithmeticOperation) -> str:
+    def visit_ArithmeticOperation(
+        self, arith_op: ArithmeticOperation, in_lambda: bool = False
+    ) -> str:
         if arith_op.operation_kind == ArithmeticOperationKind.Assignment:
             op = "|="
+            func = "assign"
         elif arith_op.operation_kind == ArithmeticOperationKind.InplaceXor:
             op = "^="
+            func = "inplace_xor"
         else:
             op = "+="
+            func = "inplace_add"
+        if in_lambda:
+            self._imports[func] = 1
+            return f"{func}({self.visit(arith_op.expression)}, {self._indent}{self.visit(arith_op.result_var)})\n"
         return f"{self._indent}{self.visit(arith_op.result_var)} {op} {self.visit(arith_op.expression)}\n"
 
     def visit_AmplitudeLoadingOperation(
-        self, amplitude_loading_op: AmplitudeLoadingOperation
+        self, amplitude_loading_op: AmplitudeLoadingOperation, in_lambda: bool = False
     ) -> str:
+        if in_lambda:
+            self._imports["assign_amplitude"] = 1
+            return f"assign_amplitude({self.visit(amplitude_loading_op.expression)}, {self._indent}{self.visit(amplitude_loading_op.result_var)})\n"
         return f"{self._indent}{self.visit(amplitude_loading_op.result_var)} *= {self.visit(amplitude_loading_op.expression)}\n"
 
-    def _print_bind_handles(self, handles: List[HandleBinding]) -> str:
+    def _print_bind_handles(self, handles: list[HandleBinding]) -> str:
         if len(handles) == 1:
             return self.visit(handles[0])
 

classiq/qmod/python_classical_type.py

@@ -26,6 +26,11 @@ if sys.version_info[0:2] >= (3, 9):
     pass
 from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 
+CARRAY_ERROR_MESSAGE = (
+    "CArray accepts one or two generic parameters in the form "
+    "`CArray[<element-type>]` or `CArray[<element-type>, <size>]`"
+)
+
 
 class PythonClassicalType:
     def convert(self, py_type: type) -> Optional[ConcreteClassicalType]:
@@ -48,16 +53,15 @@ class PythonClassicalType:
                     element_type=self.convert(array_args[0]),
                     size=get_type_hint_expr(array_args[1]),
                 )
-            raise ClassiqValueError(
-                "CArray accepts one or two generic parameters in the form "
-                "`CArray[<element-type>]` or `CArray[<element-type>, <size>]`"
-            )
+            raise ClassiqValueError(CARRAY_ERROR_MESSAGE)
         elif inspect.isclass(py_type) and dataclasses.is_dataclass(py_type):
             self.register_struct(py_type)
             return Struct(name=py_type.__name__)
         elif inspect.isclass(py_type) and isinstance(py_type, EnumMeta):
             self.register_enum(py_type)
             return Enum(name=py_type.__name__)
+        elif py_type in (CArray, list):
+            raise ClassiqValueError(CARRAY_ERROR_MESSAGE)
         return None
 
     def register_struct(self, py_type: type) -> None:

classiq/qmod/qfunc.py

@@ -1,14 +1,14 @@
-from typing import Callable, List, Literal, Optional, Union, overload
+from typing import Callable, Literal, Optional, Union, overload
 
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_function import ExternalQFunc, GenerativeQFunc, QFunc
 
-GEN_QFUNCS: List[GenerativeQFunc] = []
-DEC_QFUNCS: List[QFunc] = []
+GEN_QFUNCS: list[GenerativeQFunc] = []
+DEC_QFUNCS: list[QFunc] = []
 
 
 def set_discovered_functions(
-    dec_funcs: List[QFunc], gen_funcs: List[GenerativeQFunc]
+    dec_funcs: list[QFunc], gen_funcs: list[GenerativeQFunc]
 ) -> None:
     DEC_QFUNCS.clear()
     DEC_QFUNCS.extend(dec_funcs)