classiq 0.70.0__py3-none-any.whl → 0.71.0__py3-none-any.whl

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -2,17 +2,29 @@ from collections.abc import Sequence
 from itertools import chain, combinations
 from typing import (
     TYPE_CHECKING,
+    Any,
     Generic,
     cast,
 )
 from uuid import UUID
 
+import sympy
+
 from classiq.interface.debug_info.debug_info import FunctionDebugInfo
 from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
+    QmodStructInstance,
+)
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.generator.generated_circuit_data import OperationLevel
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
@@ -75,6 +87,16 @@ def _validate_cloning(evaluated_args: list[Evaluated]) -> None:
             )
 
 
+def _is_symbolic(arg: Any) -> bool:
+    if isinstance(arg, list):
+        return any(_is_symbolic(item) for item in arg)
+    if isinstance(arg, QmodStructInstance):
+        return any(_is_symbolic(item) for item in arg.fields.values())
+    if isinstance(arg, sympy.Basic):
+        return len(arg.free_symbols) > 0
+    return isinstance(arg, ClassicalProxy)
+
+
 class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSplitter):
     def __init__(self, interpreter: "BaseInterpreter") -> None:
         Emitter.__init__(self, interpreter)
@@ -197,7 +219,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             ].occurrences_number += 1
             return function_def
 
-        function_def = self._create_function_definition(function_context)
+        function_def = self._create_function_definition(function_context, args)
         self._expanded_functions[closure_id] = function_def
         self._top_level_scope[function_def.name] = Evaluated(
             value=function_context.closure.with_new_declaration(function_def)
@@ -210,14 +232,23 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         return function_def
 
     def _create_function_definition(
-        self, function_context: FunctionContext
+        self, function_context: FunctionContext, args: list[Evaluated]
     ) -> NativeFunctionDefinition:
-        func_def = self._builder.create_definition(function_context)
+        params = [
+            param
+            for arg, param in zip(args, function_context.positional_arg_declarations)
+            if isinstance(param, PortDeclaration)
+            or (
+                isinstance(param, ClassicalParameterDeclaration)
+                and _is_symbolic(arg.value)
+            )
+        ]
+        func_def = self._builder.create_definition(function_context, params)
 
         captured_vars = function_context.closure.captured_vars.filter_vars(
             function_context.closure
         )
-        captured_ports = captured_vars.get_captured_ports()
+        captured_ports = captured_vars.get_captured_parameters()
         if len(captured_ports) == 0:
             return func_def
         func_def.positional_arg_declarations = list(
@@ -239,15 +270,22 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         closure: FunctionClosure,
     ) -> None:
         for parameter, argument in zip(parameters, arguments):
+            param_handle = HandleBinding(name=parameter.name)
             if isinstance(argument.value, QuantumSymbol):
                 assert isinstance(parameter, PortDeclaration)
                 closure.scope[parameter.name] = Evaluated(
                     QuantumSymbol(
-                        handle=HandleBinding(name=parameter.name),
+                        handle=param_handle,
                         quantum_type=parameter.quantum_type,
                     ),
                     defining_function=closure,
                 )
+            elif _is_symbolic(argument.value):
+                assert isinstance(parameter, ClassicalParameterDeclaration)
+                closure.scope[parameter.name] = Evaluated(
+                    value=parameter.classical_type.get_classical_proxy(param_handle),
+                    defining_function=closure,
+                )
             else:
                 closure.scope[parameter.name] = argument
 
@@ -264,7 +302,9 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             return [arg.emit() for arg in evaluated_args]
 
         positional_args = [
-            arg.emit() for arg in evaluated_args if isinstance(arg.value, QuantumSymbol)
+            arg.emit()
+            for arg in evaluated_args
+            if isinstance(arg.value, QuantumSymbol) or _is_symbolic(arg.value)
         ]
 
         return positional_args

classiq/model_expansions/quantum_operations/emitter.py

@@ -19,6 +19,13 @@ from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
 )
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.utils import (
+    get_proxy_type,
+)
+from classiq.interface.generator.functions.classical_type import ClassicalType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
@@ -145,6 +152,7 @@ class Emitter(Generic[QuantumStatementT], ABC):
         return new_expression
 
     def emit_statement(self, statement: QuantumStatement) -> None:
+        self._update_captured_classical_vars(statement)
         if isinstance(statement, QuantumOperation):
             self._update_captured_vars(statement)
         if statement.uuid not in self._interpreter._model.debug_info:
@@ -153,6 +161,11 @@ class Emitter(Generic[QuantumStatementT], ABC):
             )
         self._builder.emit_statement(statement)
 
+    def _update_captured_classical_vars(self, stmt: QuantumStatement) -> None:
+        for expr in stmt.expressions:
+            for var_name, var_type in self._get_classical_vars_in_expression(expr):
+                self._capture_classical_var(var_name, var_type)
+
     def _update_captured_vars(self, op: QuantumOperation) -> None:
         handles = (
             [(handle, PortDeclarationDirection.Input) for handle in op.inputs]
@@ -178,6 +191,18 @@ class Emitter(Generic[QuantumStatementT], ABC):
             direction=direction,
         )
 
+    def _capture_classical_var(self, var_name: str, var_type: ClassicalType) -> None:
+        if var_name not in self._current_scope:
+            return
+        defining_function = self._current_scope[var_name].defining_function
+        if defining_function is None:
+            raise ClassiqInternalExpansionError
+        self._builder.current_block.captured_vars.capture_classical_var(
+            var_name=var_name,
+            var_type=var_type,
+            defining_function=defining_function,
+        )
+
     def _get_symbols_in_expression(self, expr: Expression) -> list[QuantumSymbol]:
         vrc = VarRefCollector(ignore_duplicated_handles=True)
         vrc.visit(ast.parse(expr.expr))
@@ -187,3 +212,19 @@ class Emitter(Generic[QuantumStatementT], ABC):
             if isinstance(self._current_scope[handle.name].value, QuantumSymbol)
         )
         return [self._interpreter.evaluate(handle).value for handle in handles]
+
+    def _get_classical_vars_in_expression(
+        self, expr: Expression
+    ) -> list[tuple[str, ClassicalType]]:
+        vrc = VarRefCollector(ignore_duplicated_handles=True, ignore_sympy_symbols=True)
+        vrc.visit(ast.parse(expr.expr))
+        return list(
+            {
+                handle.name: get_proxy_type(proxy)
+                for handle in vrc.var_handles
+                if handle.name in self._current_scope
+                and isinstance(
+                    proxy := self._current_scope[handle.name].value, ClassicalProxy
+                )
+            }.items()
+        )

classiq/model_expansions/quantum_operations/expression_evaluator.py

@@ -26,6 +26,10 @@ class ExpressionEvaluator(Emitter[QuantumOperation]):
         )
         for symbol in self._get_symbols_in_expression(evaluated_expression):
             self._capture_handle(symbol.handle, PortDeclarationDirection.Inout)
+        for var_name, var_type in self._get_classical_vars_in_expression(
+            evaluated_expression
+        ):
+            self._capture_classical_var(var_name, var_type)
         op = op.model_copy(
             update={self._expression_name: evaluated_expression, "back_ref": op.uuid}
         )

classiq/model_expansions/scope.py

@@ -1,13 +1,10 @@
 import itertools
-import re
 from collections import UserDict
 from collections.abc import Iterator
 from dataclasses import dataclass
 from functools import singledispatch
 from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
 
-from sympy import Symbol
-
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
@@ -16,9 +13,6 @@ from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
 )
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.expression_constants import (
-    CPARAM_EXECUTION_SUFFIX_PATTERN,
-)
 from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
 )
@@ -204,8 +198,6 @@ class Scope(EvaluatedUserDict):
             return self.data[name]
         if self._parent is not None:
             return self._parent[name]
-        if re.search(CPARAM_EXECUTION_SUFFIX_PATTERN, name):
-            return Evaluated(value=Symbol(name))
         raise ClassiqExpansionError(f"Variable {name!r} is undefined")
 
     def __contains__(self, item: Any) -> bool:

classiq/model_expansions/scope_initialization.py

@@ -7,6 +7,9 @@ from classiq.interface.generator.functions.classical_type import (
     ClassicalList,
 )
 from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
@@ -102,17 +105,24 @@ def add_entry_point_params_to_scope(
     parameters: Sequence[PositionalArg], main_closure: FunctionClosure
 ) -> None:
     for parameter in parameters:
-        if not isinstance(parameter, PortDeclaration):
-            continue
-        main_closure.scope[parameter.name] = Evaluated(
-            value=QuantumSymbol(
-                handle=HandleBinding(name=parameter.name),
-                quantum_type=evaluate_type_in_quantum_symbol(
-                    parameter.quantum_type, main_closure.scope, parameter.name
+        if isinstance(parameter, PortDeclaration):
+            main_closure.scope[parameter.name] = Evaluated(
+                value=QuantumSymbol(
+                    handle=HandleBinding(name=parameter.name),
+                    quantum_type=evaluate_type_in_quantum_symbol(
+                        parameter.quantum_type, main_closure.scope, parameter.name
+                    ),
                 ),
-            ),
-            defining_function=main_closure,
-        )
+                defining_function=main_closure,
+            )
+        elif isinstance(parameter, ClassicalParameterDeclaration):
+            param_val = parameter.classical_type.get_classical_proxy(
+                handle=HandleBinding(name=parameter.name)
+            )
+            main_closure.scope[parameter.name] = Evaluated(
+                value=param_val,
+                defining_function=main_closure,
+            )
 
 
 def init_top_level_scope(model: Model, scope: Scope) -> None:
@@ -126,24 +136,6 @@ def init_builtin_types() -> None:
     QMODULE.type_decls |= BUILTIN_STRUCT_DECLARATIONS
 
 
-def init_exec_params(model: Model, scope: Scope) -> dict[str, ConcreteClassicalType]:
-    if model.execution_parameters is not None:
-        exec_params = model.execution_parameters
-    else:
-        exec_params = {
-            param.name: param.classical_type
-            for param in model.function_dict.get(
-                "_dec_main", model.main_func
-            ).param_decls
-        }
-    for param_name, param_type in exec_params.items():
-        param_val = param_type.get_classical_proxy(
-            handle=HandleBinding(name=param_name)
-        )
-        scope[param_name] = Evaluated(value=param_val)
-    return exec_params
-
-
 def _get_shape(classical_type: ConcreteClassicalType) -> tuple[int, ...]:
     if isinstance(classical_type, ClassicalList):
         raise ClassiqInternalExpansionError("Unexpected classical list")

classiq/qmod/__init__.py

@@ -6,7 +6,7 @@ from .expression_query import get_expression_numeric_attributes
 from .qfunc import qfunc
 from .qmod_constant import QConstant
 from .qmod_parameter import Array, CArray, CBool, CInt, CReal
-from .qmod_variable import Input, Output, QArray, QBit, QNum, QStruct
+from .qmod_variable import Const, Input, Output, QArray, QBit, QFree, QNum, QStruct
 from .quantum_callable import QCallable, QCallableList
 from .write_qmod import write_qmod
 
@@ -18,6 +18,8 @@ __all__ = [
     "CReal",
     "Input",
     "Output",
+    "Const",
+    "QFree",
     "QArray",
     "QBit",
     "QNum",

classiq/qmod/declaration_inferrer.py

@@ -19,6 +19,7 @@ from classiq.interface.generator.functions.concrete_types import ConcreteClassic
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.generator.types.enum_declaration import declaration_from_enum
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
 from classiq.interface.model.classical_parameter_declaration import (
@@ -36,7 +37,7 @@ from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
 from classiq.qmod.builtins.structs import BUILTIN_STRUCT_DECLARATIONS
 from classiq.qmod.model_state_container import ModelStateContainer
 from classiq.qmod.python_classical_type import PythonClassicalType
-from classiq.qmod.qmod_variable import QVar
+from classiq.qmod.qmod_variable import QVar, get_port_from_type_hint
 from classiq.qmod.quantum_callable import QCallableList
 from classiq.qmod.semantics.validation.type_hints import validate_annotation
 from classiq.qmod.utilities import unmangle_keyword, version_portable_get_args
@@ -85,15 +86,12 @@ 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]
-    direction = qtype.port_direction(py_type)
-    if isinstance(py_type, _AnnotatedAlias):
-        py_type = py_type.__args__[0]
+    quantum_type, direction, qualifier = get_port_from_type_hint(py_type)
     param = AnonPortDeclaration(
         name=None,
         direction=direction,
-        quantum_type=qtype.to_qmod_quantum_type(py_type),
+        quantum_type=quantum_type,
+        type_qualifier=qualifier,
     )
     if name is not None:
         param = param.rename(name)
@@ -126,23 +124,45 @@ def _extract_operand_decl(
 def _extract_operand_param(py_type: Any) -> tuple[Optional[str], Any]:
     if get_origin(py_type) is not Annotated:
         return None, py_type
+
     args = get_args(py_type)
-    if len(args) == 2:
-        if isinstance(args[1], PortDeclarationDirection):
-            return None, py_type
-        elif isinstance(args[1], str):
-            return args[1], args[0]
-        elif get_origin(args[1]) is Literal:
-            return version_portable_get_args(args[1])[0], args[0]
-    elif len(args) == 3 and isinstance(args[1], PortDeclarationDirection):
-        if isinstance(args[2], str):
-            return args[2], Annotated[args[0], args[1]]
-        elif get_origin(args[2]) is Literal:
-            return version_portable_get_args(args[2])[0], Annotated[args[0], args[1]]
-    raise ClassiqValueError(
-        f"Operand parameter declaration must be of the form <param-type> or "
-        f"Annotated[<param-type>, <param-name>]. Got {py_type}"
-    )
+    _validate_annotations(args, py_type)
+    param_name = _get_param_name(args)
+
+    if param_name is None:
+        if len(args) > 1:
+            return None, _unpacked_annotated(args[0], args[1:])
+        return None, args[0]
+
+    if len(args) > 2:
+        return param_name, _unpacked_annotated(args[0], args[1:-1])
+    return param_name, args[0]
+
+
+def _unpacked_annotated(arg_0: Any, args: Any) -> _AnnotatedAlias:
+    return Annotated.__class_getitem__((arg_0, *args))  # type:ignore[attr-defined]
+
+
+def _get_param_name(py_type_args: Any) -> Optional[str]:
+    if isinstance(py_type_args[-1], str) and not isinstance(
+        py_type_args[-1], (PortDeclarationDirection, TypeQualifier)
+    ):
+        return py_type_args[-1]
+    elif py_type_args[-1] is Literal:
+        return str(version_portable_get_args(py_type_args[-1])[0])  # type: ignore[arg-type]
+    else:
+        return None
+
+
+def _validate_annotations(py_type_args: Any, py_type: Any) -> None:
+    for arg in py_type_args[1:-1]:
+        if (
+            isinstance(arg, str) and not isinstance(arg, PortDeclarationDirection)
+        ) or arg is Literal:
+            raise ClassiqValueError(
+                f"Operand parameter declaration must be of the form <param-type> or "
+                f"Annotated[<param-type>, <param-name>]. Got {py_type}"
+            )
 
 
 @overload
@@ -177,7 +197,7 @@ def _extract_positional_args(
             if name is not None:
                 param = param.rename(name)
             result.append(param)
-        elif QVar.from_type_hint(py_type) is not None:
+        elif is_qvar(py_type):
             result.append(_extract_port_decl(name, py_type))
         else:
             result.append(_extract_operand_decl(name, py_type, qmodule=qmodule))
@@ -193,3 +213,11 @@ def infer_func_decl(
             list(py_func.__annotations__.items()), qmodule=qmodule
         ),
     )
+
+
+def is_qvar(type_hint: Any) -> Any:
+    non_annotated_type = (
+        type_hint.__origin__ if isinstance(type_hint, _AnnotatedAlias) else type_hint
+    )
+    type_ = get_origin(non_annotated_type) or non_annotated_type
+    return issubclass(type_, QVar)

classiq/qmod/native/pretty_printer.py

@@ -18,6 +18,8 @@ from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.generator.functions.type_qualifier import TypeQualifier
+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
@@ -95,6 +97,7 @@ class DSLPrettyPrinter(ModelVisitor):
         self._level = 0
         self._decimal_precision = decimal_precision
         self._emit_open_lib_functions = emit_open_lib_functions
+        self._compilation_metadata: dict[str, CompilationMetadata] = {}
 
     def visit(self, node: NodeType) -> str:
         res = super().visit(node)
@@ -105,6 +108,8 @@ class DSLPrettyPrinter(ModelVisitor):
     def visit_Model(self, model: Model) -> str:
         # FIXME - CAD-20149: Remove this line once the froggies are removed, and the visit of lambdas can be done without accessing the func_decl property (with rename_params values only).
         resolve_function_calls(model, model.function_dict)
+        self._compilation_metadata = model.functions_compilation_metadata
+
         enum_decls = [self.visit(enum_decl) for enum_decl in model.enums]
         struct_decls = [self.visit(struct_decl) for struct_decl in model.types]
         qstruct_decls = [self.visit(qstruct_decl) for qstruct_decl in model.qstructs]
@@ -135,10 +140,20 @@ class DSLPrettyPrinter(ModelVisitor):
         )
         return f"({positional_args})"
 
+    def _get_decl_string(self, func_decl: QuantumFunctionDeclaration) -> str:
+        no_qualifiers_decl = "qfunc"
+        if func_decl.name not in self._compilation_metadata:
+            return no_qualifiers_decl
+        atomic_qualifiers = self._compilation_metadata[func_decl.name].atomic_qualifiers
+        if len(atomic_qualifiers) == 0:
+            return no_qualifiers_decl
+        return f"atomic_qualifiers ({', '.join(atomic_qualifiers)})\n" f"qfunc"
+
     def visit_QuantumFunctionDeclaration(
         self, func_decl: QuantumFunctionDeclaration
     ) -> str:
-        return f"qfunc {func_decl.name}{self._visit_arg_decls(func_decl)}"
+        qfunc_decl = self._get_decl_string(func_decl)
+        return f"{qfunc_decl} {func_decl.name}{self._visit_arg_decls(func_decl)}"
 
     def visit_EnumDeclaration(self, enum_decl: EnumDeclaration) -> str:
         return f"enum {enum_decl.name} {{\n{self._visit_members(enum_decl.members)}}}\n"
@@ -175,13 +190,20 @@ class DSLPrettyPrinter(ModelVisitor):
         return f"{var_decl.name}: {self.visit(var_decl.quantum_type)}"
 
     def visit_AnonPortDeclaration(self, port_decl: AnonPortDeclaration) -> str:
+        qualifier_str = (
+            f"{port_decl.type_qualifier} "
+            if port_decl.type_qualifier is not TypeQualifier.Quantum
+            else ""
+        )
         dir_str = (
             f"{port_decl.direction} "
-            if port_decl.direction != PortDeclarationDirection.Inout
+            if port_decl.direction is not PortDeclarationDirection.Inout
             else ""
         )
         param_name = f"{port_decl.name}: " if port_decl.name is not None else ""
-        return f"{dir_str}{param_name}{self.visit(port_decl.quantum_type)}"
+        return (
+            f"{qualifier_str}{dir_str}{param_name}{self.visit(port_decl.quantum_type)}"
+        )
 
     def visit_QuantumBit(self, qtype: QuantumBit) -> str:
         return "qbit"

classiq/qmod/pretty_print/pretty_printer.py

@@ -21,6 +21,8 @@ from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.generator.functions.type_qualifier import TypeQualifier
+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
@@ -131,6 +133,7 @@ class PythonPrettyPrinter(ModelVisitor):
         self._import_annotated = False
         self._symbolic_imports: dict[str, int] = dict()
         self._functions: Optional[Mapping[str, QuantumFunctionDeclaration]] = None
+        self._compilation_metadata: dict[str, CompilationMetadata] = dict()
 
     def visit(self, node: NodeType) -> str:
         res = super().visit(node)
@@ -140,6 +143,7 @@ class PythonPrettyPrinter(ModelVisitor):
 
     def visit_Model(self, model: Model) -> str:
         self._functions = {**model.function_dict, **BUILTIN_FUNCTION_DECLARATIONS}
+        self._compilation_metadata = model.functions_compilation_metadata
         enum_decls = [self.visit(decl) for decl in model.enums]
         struct_decls = [self.visit(decl) for decl in model.types]
         qstruct_decls = [self.visit(qstruct_decl) for qstruct_decl in model.qstructs]
@@ -196,12 +200,23 @@ class PythonPrettyPrinter(ModelVisitor):
             self.visit(arg_decl) for arg_decl in func_def.positional_arg_declarations
         )
 
+    def _get_qfunc_decorator(self, func_decl: QuantumFunctionDeclaration) -> str:
+        no_qualifiers_decorator = "@qfunc"
+        if func_decl.name not in self._compilation_metadata:
+            return no_qualifiers_decorator
+        atomic_qualifiers = self._compilation_metadata[func_decl.name].atomic_qualifiers
+        if len(atomic_qualifiers) == 0:
+            return no_qualifiers_decorator
+
+        qualifiers = (f'"{qualifier}"' for qualifier in atomic_qualifiers)
+        qualifier_list = f"[{', '.join(qualifiers)}]"
+        return no_qualifiers_decorator + f" (atomic_qualifiers={qualifier_list})"
+
     def visit_QuantumFunctionDeclaration(
         self, func_decl: QuantumFunctionDeclaration
     ) -> str:
-        return (
-            f"@qfunc\ndef {func_decl.name}({self._visit_arg_decls(func_decl)}) -> None:"
-        )
+        qfunc_decorator = self._get_qfunc_decorator(func_decl)
+        return f"{qfunc_decorator}\ndef {func_decl.name}({self._visit_arg_decls(func_decl)}) -> None:"
 
     def visit_EnumDeclaration(self, enum_decl: EnumDeclaration) -> str:
         self._import_enum = True
@@ -241,16 +256,18 @@ class PythonPrettyPrinter(ModelVisitor):
         return f"{var_decl.name}: {self.visit(var_decl.quantum_type)}"
 
     def visit_AnonPortDeclaration(self, port_decl: AnonPortDeclaration) -> str:
-        var = f"{port_decl.name}: {self.visit(port_decl.quantum_type)}"
-        var_name, var_type = var.split(": ")
-        for direction in PortDeclarationDirection:
-            if port_decl.direction == PortDeclarationDirection.Inout:
-                return var
-            if port_decl.direction == direction:
-                direction_identifier = direction.name
-                self._imports[direction_identifier] = 1
-                return f"{var_name}: {direction_identifier}[{var_type}]"
-        raise RuntimeError("Should not reach here")
+        var_type = self._extract_port_type(port_decl)
+        return f"{port_decl.name}: {var_type}"
+
+    def _extract_port_type(self, port_decl: AnonPortDeclaration) -> str:
+        var_type = self.visit(port_decl.quantum_type)
+        if port_decl.direction is not PortDeclarationDirection.Inout:
+            self._imports[port_decl.direction.name] = 1
+            var_type = f"{port_decl.direction.name}[{var_type}]"
+        if port_decl.type_qualifier is not TypeQualifier.Quantum:
+            self._imports[port_decl.type_qualifier.name] = 1
+            var_type = f"{port_decl.type_qualifier.name}[{var_type}]"
+        return var_type
 
     def visit_QuantumBit(self, qtype: QuantumBit) -> str:
         self._imports["QBit"] = 1
@@ -349,7 +366,7 @@ class PythonPrettyPrinter(ModelVisitor):
 
     def _visit_operand_arg_decl(self, arg_decl: AnonPositionalArg) -> str:
         if isinstance(arg_decl, AnonPortDeclaration):
-            type_str = self.visit(arg_decl.quantum_type)
+            type_str = self._extract_port_type(arg_decl)
         elif isinstance(arg_decl, AnonClassicalParameterDeclaration):
             type_str = self.visit(arg_decl.classical_type)
         else:

classiq/qmod/python_classical_type.py

@@ -2,6 +2,9 @@ import dataclasses
 import inspect
 from enum import EnumMeta
 from typing import (
+    Any,
+    ForwardRef,
+    Literal,
     Optional,
     get_args,
     get_origin,
@@ -19,7 +22,6 @@ from classiq.interface.generator.functions.concrete_types import ConcreteClassic
 from classiq.interface.generator.functions.type_name import Enum, Struct
 
 from classiq.qmod.cparam import CArray, CBool, CInt, CReal
-from classiq.qmod.qmod_variable import get_type_hint_expr
 from classiq.qmod.utilities import version_portable_get_args
 
 CARRAY_ERROR_MESSAGE = (
@@ -71,3 +73,12 @@ class PythonClassicalType:
 
     def register_enum(self, py_type: EnumMeta) -> None:
         pass
+
+
+def get_type_hint_expr(type_hint: Any) -> str:
+    if isinstance(type_hint, ForwardRef):  # expression in string literal
+        return str(type_hint.__forward_arg__)
+    if get_origin(type_hint) == Literal:  # explicit numeric literal
+        return str(get_args(type_hint)[0])
+    else:
+        return str(type_hint)  # implicit numeric literal