classiq 0.76.0__py3-none-any.whl → 0.77.0__py3-none-any.whl

classiq/model_expansions/function_builder.py

@@ -11,12 +11,15 @@ from classiq.interface.generator.compiler_keywords import (
 from classiq.interface.generator.functions.builtins.internal_operators import (
     WITHIN_APPLY_NAME,
 )
+from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.model.model import MAIN_FUNCTION_NAME
 from classiq.interface.model.native_function_definition import (
     NativeFunctionDefinition,
 )
+from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
     PositionalArg,
+    QuantumOperandDeclaration,
 )
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.variable_declaration_statement import (
@@ -212,6 +215,7 @@ class OperationBuilder:
         self, function_context: FunctionContext, params: Sequence[PositionalArg]
     ) -> NativeFunctionDefinition:
         name = self._get_expanded_function_name(function_context)
+        self._override_type_qualifier(function_context, params)
 
         return NativeFunctionDefinition(
             name=name,
@@ -244,3 +248,44 @@ class OperationBuilder:
             raise ClassiqInternalExpansionError("Could not allocate function name")
 
         return name
+
+    def _override_type_qualifier(
+        self, function_context: FunctionContext, params: Sequence[PositionalArg]
+    ) -> None:
+        """
+        The type qualifier can be changed according to the operand passed to the
+        function. For example,
+        apply_to_all(X, q) --> q will be QFree after expansion
+        apply_to_all(H, q) --> q will be Quantum after expansion
+        This also holds for the intermediate lambda created during the expansion.
+
+        We don't override the type qualifier if it's explicitly specified (QFree or
+        Const), neither in the function declaration nor in the operand declaration.
+        """
+
+        if function_context.is_lambda:
+            self._update_type_qualifiers(params)
+            return
+
+        orig_name = function_context.name
+        if orig_name == MAIN_FUNCTION_NAME or orig_name not in self.current_scope:
+            return
+
+        orig_func = self.current_scope[orig_name].value
+        if not any(
+            isinstance(param_decl, QuantumOperandDeclaration)
+            for param_decl in orig_func.positional_arg_declarations
+        ):
+            return
+
+        self._update_type_qualifiers(params)
+
+    @staticmethod
+    def _update_type_qualifiers(params: Sequence[PositionalArg]) -> None:
+        # only override the qualifier if it's unspecified (not QFree or Const)
+        for param in params:
+            if (
+                isinstance(param, PortDeclaration)
+                and param.type_qualifier is TypeQualifier.Quantum
+            ):
+                param.type_qualifier = TypeQualifier.Inferred

classiq/model_expansions/generative_functions.py

@@ -134,7 +134,7 @@ class _InterpreterExpandable(QFunc):
         dummy_function = NativeFunctionDefinition(
             name=current_operation.name,
             positional_arg_declarations=current_operation.positional_arg_declarations,
-            body=self._interpreter._builder._current_statements + [stmt],
+            body=[stmt],
         )
         declarative_functions = {
             name: func

classiq/model_expansions/interpreters/base_interpreter.py

@@ -24,6 +24,7 @@ from classiq.interface.generator.types.compilation_metadata import CompilationMe
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
     HandleBinding,
+    HandlesList,
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
@@ -51,7 +52,12 @@ from classiq.model_expansions.function_builder import (
     OperationBuilder,
     OperationContext,
 )
-from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+from classiq.model_expansions.scope import (
+    Evaluated,
+    QuantumSymbol,
+    QuantumSymbolList,
+    Scope,
+)
 from classiq.model_expansions.scope_initialization import (
     add_entry_point_params_to_scope,
     init_builtin_types,
@@ -233,6 +239,14 @@ class BaseInterpreter:
             )
         return Evaluated(value=fields[field_name])
 
+    @evaluate.register
+    def evaluate_handles_list(self, handles_list: HandlesList) -> Evaluated:
+        return Evaluated(
+            value=QuantumSymbolList.from_symbols(
+                [self.evaluate(handle).value for handle in handles_list.handles]
+            )
+        )
+
     @abstractmethod
     def emit(self, statement: QuantumStatement) -> None:
         pass

classiq/model_expansions/interpreters/frontend_generative_interpreter.py

@@ -1,5 +1,6 @@
 import inspect
 import os
+from typing import Optional
 
 from pydantic import ValidationError
 
@@ -33,9 +34,9 @@ class FrontendGenerativeInterpreter(GenerativeInterpreter):
     def infer_symbolic_parameters(
         self,
         functions: list[NativeFunctionDefinition],
-        additional_signatures: (
-            list[NamedParamsQuantumFunctionDeclaration] | None
-        ) = None,
+        additional_signatures: Optional[
+            list[NamedParamsQuantumFunctionDeclaration]
+        ] = None,
     ) -> None:
         SymbolicParamInference(functions, additional_signatures).infer()
 

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -1,5 +1,5 @@
 from functools import singledispatchmethod
-from typing import Any
+from typing import Any, Optional
 
 import numpy as np
 from numpy.random import permutation
@@ -104,9 +104,9 @@ class GenerativeInterpreter(BaseInterpreter):
     def infer_symbolic_parameters(
         self,
         functions: list[NativeFunctionDefinition],
-        additional_signatures: (
-            list[NamedParamsQuantumFunctionDeclaration] | None
-        ) = None,
+        additional_signatures: Optional[
+            list[NamedParamsQuantumFunctionDeclaration]
+        ] = None,
     ) -> None:
         pass
 

classiq/model_expansions/quantum_operations/allocate.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 import sympy
 
@@ -49,7 +49,7 @@ class AllocateEmitter(Emitter[Allocate]):
         self.emit_statement(allocate)
         return True
 
-    def _get_var_size(self, target: QuantumSymbol, size: Expression | None) -> str:
+    def _get_var_size(self, target: QuantumSymbol, size: Optional[Expression]) -> str:
         if size is None:
             if not target.quantum_type.is_evaluated:
                 raise ClassiqValueError(

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
 from classiq.interface.generator.expressions.expression import Expression
@@ -69,7 +71,7 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         self._assign_to_inferred_var_and_bind(op, result_type, inferred_result_type)
         return True
 
-    def _infer_result_type(self, op: ArithmeticOperation) -> QuantumNumeric | None:
+    def _infer_result_type(self, op: ArithmeticOperation) -> Optional[QuantumNumeric]:
         expr = self._evaluate_expression(op.expression)
         if len(self._get_classical_vars_in_expression(expr)):
             return None

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -4,6 +4,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Generic,
+    Optional,
     cast,
 )
 from uuid import UUID
@@ -62,7 +63,13 @@ from classiq.model_expansions.quantum_operations.emitter import (
     Emitter,
     QuantumStatementT,
 )
-from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+from classiq.model_expansions.scope import (
+    Evaluated,
+    QuantumSymbol,
+    QuantumSymbolList,
+    QuantumVariable,
+    Scope,
+)
 from classiq.model_expansions.transformers.var_splitter import VarSplitter
 from classiq.model_expansions.utils.text_utils import are, readable_list, s
 from classiq.qmod.semantics.validation.signature_validation import (
@@ -74,11 +81,14 @@ if TYPE_CHECKING:
 
 
 def _validate_cloning(evaluated_args: list[Evaluated]) -> None:
-    handles = [
-        arg.value.handle
+    handles = chain.from_iterable(
+        (
+            [arg.value.handle]
+            if isinstance(arg.value, QuantumSymbol)
+            else arg.value.handles if isinstance(arg.value, QuantumSymbolList) else []
+        )
         for arg in evaluated_args
-        if isinstance(arg.value, QuantumSymbol)
-    ]
+    )
     for handle, other_handle in combinations(handles, 2):
         if handle.overlaps(other_handle):
             if handle == other_handle:
@@ -130,7 +140,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         self,
         function: FunctionClosure,
         args: list[ArgValue],
-        propagated_debug_info: FunctionDebugInfo | None,
+        propagated_debug_info: Optional[FunctionDebugInfo],
     ) -> QuantumFunctionCall:
         call = self._create_quantum_function_call(
             function, args, propagated_debug_info=propagated_debug_info
@@ -140,8 +150,8 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
 
     @staticmethod
     def _get_back_ref(
-        propagated_debug_info: FunctionDebugInfo | None,
-    ) -> UUID | None:
+        propagated_debug_info: Optional[FunctionDebugInfo],
+    ) -> Optional[UUID]:
         if propagated_debug_info is None:
             return None
         if propagated_debug_info.node is None:
@@ -152,7 +162,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         self,
         function: FunctionClosure,
         args: list[ArgValue],
-        propagated_debug_info: FunctionDebugInfo | None,
+        propagated_debug_info: Optional[FunctionDebugInfo],
     ) -> QuantumFunctionCall:
         function = function.clone()
         function = function.set_depth(self._builder.current_function.depth + 1)
@@ -281,7 +291,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
     ) -> None:
         for parameter, argument in zip(parameters, arguments):
             param_handle = HandleBinding(name=parameter.name)
-            if isinstance(argument.value, QuantumSymbol):
+            if isinstance(argument.value, QuantumVariable):
                 assert isinstance(parameter, PortDeclaration)
                 closure.scope[parameter.name] = Evaluated(
                     QuantumSymbol(
@@ -314,7 +324,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         positional_args = [
             arg.emit()
             for arg in evaluated_args
-            if isinstance(arg.value, QuantumSymbol) or _is_symbolic(arg.value)
+            if isinstance(arg.value, QuantumVariable) or _is_symbolic(arg.value)
         ]
 
         return positional_args

classiq/model_expansions/quantum_operations/emitter.py

@@ -181,12 +181,7 @@ class Emitter(Generic[QuantumStatementT], ABC):
             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]
-            + [(handle, PortDeclarationDirection.Output) for handle in op.outputs]
-            + [(handle, PortDeclarationDirection.Inout) for handle in op.inouts]
-        )
-        for handle, direction in handles:
+        for handle, direction in op.handles_with_directions:
             self._capture_handle(handle, direction)
 
     def _capture_handle(

classiq/model_expansions/scope.py

@@ -22,7 +22,9 @@ from classiq.interface.generator.expressions.proxies.classical.qmod_struct_insta
 from classiq.interface.generator.functions.type_name import TypeName
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
+    GeneralHandle,
     HandleBinding,
+    HandlesList,
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
@@ -39,10 +41,17 @@ T = TypeVar("T")
 
 
 @dataclass(frozen=True)
-class QuantumSymbol:
-    handle: HandleBinding
+class QuantumVariable:
     quantum_type: QuantumType
 
+    def emit(self) -> GeneralHandle:
+        raise NotImplementedError
+
+
+@dataclass(frozen=True)
+class QuantumSymbol(QuantumVariable):
+    handle: HandleBinding
+
     @property
     def is_subscript(self) -> bool:
         return isinstance(self.handle, (SubscriptHandleBinding, SlicedHandleBinding))
@@ -140,6 +149,47 @@ class QuantumSymbol:
             for field_name, field_type in quantum_type.fields.items()
         }
 
+    def __str__(self) -> str:
+        return str(self.handle)
+
+
+@dataclass(frozen=True)
+class QuantumSymbolList(QuantumVariable):
+    handles: list[HandleBinding]
+
+    @staticmethod
+    def from_symbols(
+        symbols: list[Union[QuantumSymbol, "QuantumSymbolList"]],
+    ) -> "QuantumSymbolList":
+        handles = list(
+            itertools.chain.from_iterable(
+                (
+                    symbol.handles
+                    if isinstance(symbol, QuantumSymbolList)
+                    else [symbol.handle]
+                )
+                for symbol in symbols
+            )
+        )
+        if len(handles) == 0:
+            raise ClassiqExpansionError("Empty concatenation expression")
+        length: Optional[Expression]
+        if any(not symbol.quantum_type.has_size_in_bits for symbol in symbols):
+            length = None
+        else:
+            length = Expression(
+                expr=str(sum(symbol.quantum_type.size_in_bits for symbol in symbols))
+            )
+        return QuantumSymbolList(
+            handles=handles, quantum_type=QuantumBitvector(length=length)
+        )
+
+    def emit(self) -> HandlesList:
+        return HandlesList(handles=self.handles)
+
+    def __str__(self) -> str:
+        return str(self.handles)
+
 
 @singledispatch
 def evaluated_to_str(value: Any) -> str:
@@ -183,7 +233,7 @@ class Evaluated:  # FIXME: Merge with EvaluatedExpression if possible
     def emit(self) -> ArgValue:
         from classiq.model_expansions.closure import FunctionClosure
 
-        if isinstance(self.value, (QuantumSymbol, FunctionClosure)):
+        if isinstance(self.value, (QuantumVariable, FunctionClosure)):
             return self.value.emit()
         if isinstance(self.value, list) and all(
             isinstance(item, FunctionClosure) for item in self.value

classiq/model_expansions/transformers/model_renamer.py

@@ -33,7 +33,7 @@ def _handle_contains_handle(handle: HandleBinding, other_handle: HandleBinding)
     return 0
 
 
-class _ExprNormalizer(ast.NodeTransformer):
+class ExprNormalizer(ast.NodeTransformer):
     def visit_Call(self, node: ast.Call) -> ast.AST:
         if not isinstance(node.func, ast.Name):
             return self.generic_visit(node)
@@ -74,7 +74,7 @@ SymbolRenaming = Mapping[HandleBinding, Sequence[HandleRenaming]]
 def _rewrite_expression(
     symbol_mapping: SymbolRenaming, expression: Expression
 ) -> Expression:
-    normalized_expr = _ExprNormalizer().visit(ast.parse(expression.expr))
+    normalized_expr = ExprNormalizer().visit(ast.parse(expression.expr))
     vrc = VarRefCollector(
         ignore_duplicated_handles=True, ignore_sympy_symbols=True, unevaluated=True
     )

classiq/model_expansions/visitors/symbolic_param_inference.py

@@ -62,9 +62,9 @@ class SymbolicParamInference(ModelVisitor):
     def __init__(
         self,
         functions: list[NativeFunctionDefinition],
-        additional_signatures: (
-            list[NamedParamsQuantumFunctionDeclaration] | None
-        ) = None,
+        additional_signatures: Optional[
+            list[NamedParamsQuantumFunctionDeclaration]
+        ] = None,
     ) -> None:
         self._functions = nameables_to_dict(functions)
         self._additional_signatures = (

classiq/open_library/functions/lookup_table.py

@@ -39,7 +39,7 @@ def span_lookup_table(func: RealFunction, *targets: QNum) -> QNum:
         The quantum result of applying func to targets
 
     Notes:
-        Must be called inside a generative function (`@qfunc(generative=True)`)
+        Must be called inside a generative function (`@qfunc`)
     """
     if len(targets) == 0:
         raise ClassiqValueError("No targets specified")

classiq/open_library/functions/state_preparation.py

@@ -334,7 +334,7 @@ def _classical_hadamard_transform(arr: list[float]) -> np.ndarray:
     return 1 / np.sqrt(len(arr)) * np.array(sympy.fwht(np.array(arr)))
 
 
-@qfunc(generative=True)
+@qfunc
 def _load_phases(
     phases: list[float],
     target: QArray[QBit, Literal["log(get_field(phases, 'len'), 2)"]],

classiq/qmod/create_model_function.py

@@ -1,4 +1,4 @@
-from typing import Optional, Union
+from typing import Optional, Union, cast
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
@@ -7,10 +7,26 @@ from classiq.interface.generator.model.preferences.preferences import Preference
 from classiq.interface.model.model import MAIN_FUNCTION_NAME, SerializedModel
 
 from classiq.qmod.classical_function import CFunc
-from classiq.qmod.quantum_function import GenerativeQFunc, QFunc
+from classiq.qmod.quantum_function import BaseQFunc, GenerativeQFunc, QFunc
 from classiq.qmod.write_qmod import write_qmod
 
 
+class _EntryPointWrapper(str):
+    entry_point: BaseQFunc
+
+
+def add_entry_point(
+    new_model: SerializedModel, old_model: SerializedModel
+) -> SerializedModel:
+    if not hasattr(old_model, "entry_point"):
+        return new_model
+    new_model_with_entry_point = _EntryPointWrapper(new_model)
+    new_model_with_entry_point.entry_point = cast(
+        _EntryPointWrapper, old_model
+    ).entry_point
+    return cast(SerializedModel, new_model_with_entry_point)
+
+
 def create_model(
     entry_point: Union[QFunc, GenerativeQFunc],
     constraints: Optional[Constraints] = None,
@@ -48,7 +64,9 @@ def create_model(
         preferences,
         classical_execution_function,
     )
-    result = model.get_model()
+    serialized_model = _EntryPointWrapper(model.get_model())
+    serialized_model.entry_point = entry_point
+    result = cast(SerializedModel, serialized_model)
 
     if out_file is not None:
         write_qmod(result, out_file)

classiq/qmod/global_declarative_switch.py

@@ -0,0 +1,19 @@
+from collections.abc import Iterator
+from contextlib import contextmanager
+
+_DECLARATIVE_SWITCH = False
+
+
+def get_global_declarative_switch() -> bool:
+    return _DECLARATIVE_SWITCH
+
+
+@contextmanager
+def set_global_declarative_switch() -> Iterator[None]:
+    global _DECLARATIVE_SWITCH
+    previous = _DECLARATIVE_SWITCH
+    _DECLARATIVE_SWITCH = True
+    try:
+        yield
+    finally:
+        _DECLARATIVE_SWITCH = previous

classiq/qmod/native/pretty_printer.py

@@ -35,6 +35,7 @@ from classiq.interface.model.control import Control
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
     HandleBinding,
+    HandlesList,
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
@@ -395,6 +396,9 @@ class DSLPrettyPrinter(ModelVisitor):
     def visit_FieldHandleBinding(self, var_ref: FieldHandleBinding) -> str:
         return f"{self.visit(var_ref.base_handle)}.{self.visit(var_ref.field)}"
 
+    def visit_HandlesList(self, handles: HandlesList) -> str:
+        return f"{{{', '.join(map(self.visit, handles.handles))}}}"
+
     def visit_ArithmeticOperation(self, arith_op: ArithmeticOperation) -> str:
         if arith_op.operation_kind == ArithmeticOperationKind.Assignment:
             op = "="

classiq/qmod/pretty_print/pretty_printer.py

@@ -37,6 +37,7 @@ from classiq.interface.model.control import Control
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
     HandleBinding,
+    HandlesList,
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
@@ -518,6 +519,9 @@ class PythonPrettyPrinter(ModelVisitor):
     def visit_FieldHandleBinding(self, var_ref: FieldHandleBinding) -> str:
         return f"{self.visit(var_ref.base_handle)}.{self.visit(var_ref.field)}"
 
+    def visit_HandlesList(self, handles: HandlesList) -> str:
+        return self.visit(handles.handles)
+
     def visit_ArithmeticOperation(
         self, arith_op: ArithmeticOperation, in_lambda: bool = False
     ) -> str:

classiq/qmod/qfunc.py

@@ -1,9 +1,9 @@
-from collections.abc import Iterator
-from contextlib import contextmanager
+import warnings
 from typing import Callable, Literal, Optional, Union, overload
 
-from classiq.interface.exceptions import ClassiqInternalError
+from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqInternalError
 
+from classiq.qmod.global_declarative_switch import get_global_declarative_switch
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_function import (
     BaseQFunc,
@@ -12,22 +12,9 @@ from classiq.qmod.quantum_function import (
     QFunc,
 )
 
-_GENERATIVE_SWITCH = False
-
-
-@contextmanager
-def set_global_generative_switch() -> Iterator[None]:
-    global _GENERATIVE_SWITCH
-    previous = _GENERATIVE_SWITCH
-    _GENERATIVE_SWITCH = True
-    try:
-        yield
-    finally:
-        _GENERATIVE_SWITCH = previous
-
 
 @overload
-def qfunc(func: Callable) -> QFunc: ...
+def qfunc(func: Callable) -> GenerativeQFunc: ...
 
 
 @overload
@@ -42,16 +29,16 @@ def qfunc(
 @overload
 def qfunc(
     *,
-    generative: Literal[True],
+    generative: Literal[False],
     synthesize_separately: bool = False,
     atomic_qualifiers: Optional[list[str]] = None,
-) -> Callable[[Callable], GenerativeQFunc]: ...
+) -> Callable[[Callable], QFunc]: ...
 
 
 @overload
 def qfunc(
     *, synthesize_separately: bool, atomic_qualifiers: Optional[list[str]] = None
-) -> Callable[[Callable], QFunc]: ...
+) -> Callable[[Callable], GenerativeQFunc]: ...
 
 
 @overload
@@ -59,17 +46,38 @@ def qfunc(
     *,
     synthesize_separately: bool = False,
     atomic_qualifiers: Optional[list[str]] = None,
-) -> Callable[[Callable], QFunc]: ...
+) -> Callable[[Callable], GenerativeQFunc]: ...
 
 
 def qfunc(
     func: Optional[Callable] = None,
     *,
     external: bool = False,
-    generative: bool = False,
+    generative: Optional[bool] = None,
     synthesize_separately: bool = False,
     atomic_qualifiers: Optional[list[str]] = None,
 ) -> Union[Callable[[Callable], QCallable], QCallable]:
+    if generative is True:
+        warnings.warn(
+            "The use of `generative=True` is no longer required. Note that the "
+            "treatment of parameters of Qmod types will change from Python value to "
+            "symbolic in a near release. Change Qmod types to the corresponding Python "
+            "built-in types in order to use the parameters in Python expression "
+            "contexts.\n"
+            "Recommended changes:\n"
+            "@qfunc(generative=True) -> @qfunc\n"
+            "CInt->int\n"
+            "CReal->float\n"
+            "CArray->list\n\n"
+            "For more information see https://docs.classiq.io/latest/qmod-reference/language-reference/generative-descriptions/",
+            ClassiqDeprecationWarning,
+            stacklevel=2,
+        )
+    elif generative is None:
+        generative = True
+    if get_global_declarative_switch():
+        generative = False
+
     def wrapper(func: Callable) -> QCallable:
         qfunc: BaseQFunc
 
@@ -77,7 +85,7 @@ def qfunc(
             _validate_directives(synthesize_separately, atomic_qualifiers)
             return ExternalQFunc(func)
 
-        if generative or _GENERATIVE_SWITCH:
+        if generative:
             qfunc = GenerativeQFunc(func)
         else:
             qfunc = QFunc(func)