classiq 0.38.0__py3-none-any.whl → 0.65.4__py3-none-any.whl

classiq/qmod/quantum_callable.py

@@ -14,12 +14,14 @@ from typing_extensions import ParamSpec
 
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
+    AnonQuantumFunctionDeclaration,
 )
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.quantum_type import QuantumType
+from classiq.interface.source_reference import SourceReference
 
-from classiq.qmod.qmod_parameter import QParam
+from classiq.qmod.cparam import CInt
+from classiq.qmod.utilities import get_source_ref
 
 if TYPE_CHECKING:
     from classiq.qmod.quantum_expandable import QTerminalCallable
@@ -33,23 +35,30 @@ class QExpandableInterface(ABC):
         raise NotImplementedError()
 
     @abstractmethod
-    def add_local_handle(self, name: str, qtype: QuantumType) -> None:
+    def add_local_handle(
+        self,
+        name: str,
+        qtype: QuantumType,
+        source_ref: Optional[SourceReference] = None,
+    ) -> None:
         raise NotImplementedError()
 
 
 class QCallable(Generic[P], ABC):
     CURRENT_EXPANDABLE: ClassVar[Optional[QExpandableInterface]] = None
+    FRAME_DEPTH = 1
 
     def __call__(self, *args: Any, **kwargs: Any) -> None:
         assert QCallable.CURRENT_EXPANDABLE is not None
+        source_ref = get_source_ref(sys._getframe(self.FRAME_DEPTH))
         QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-            self.create_quantum_function_call(*args, **kwargs)
+            self.create_quantum_function_call(source_ref, *args, **kwargs)
         )
         return
 
     @property
     @abstractmethod
-    def func_decl(self) -> QuantumFunctionDeclaration:
+    def func_decl(self) -> AnonQuantumFunctionDeclaration:
         raise NotImplementedError
 
     # Support comma-separated generic args in older Python versions
@@ -60,7 +69,7 @@ class QCallable(Generic[P], ABC):
 
     @abstractmethod
     def create_quantum_function_call(
-        self, *args: Any, **kwargs: Any
+        self, source_ref_: SourceReference, *args: Any, **kwargs: Any
     ) -> QuantumFunctionCall:
         raise NotImplementedError()
 
@@ -68,7 +77,8 @@ class QCallable(Generic[P], ABC):
 class QCallableList(QCallable, Generic[P], ABC):
     if TYPE_CHECKING:
 
+        @property
         def len(self) -> int: ...
 
-        def __getitem__(self, key: Union[slice, int, QParam]) -> "QTerminalCallable":
+        def __getitem__(self, key: Union[slice, int, CInt]) -> "QTerminalCallable":
             raise NotImplementedError()

classiq/qmod/quantum_expandable.py

@@ -1,68 +1,87 @@
 import inspect
 from abc import ABC
+from dataclasses import is_dataclass
+from enum import Enum as PythonEnum
 from types import TracebackType
 from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
     ClassVar,
-    Dict,
-    List,
     Optional,
-    Type,
     Union,
     cast,
     overload,
 )
 
+import pydantic
+from sympy import Basic
 from typing_extensions import Self
 
+from classiq.interface.exceptions import ClassiqInternalError, ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.concrete_types import (
+    NativePythonClassicalTypes,
+    PythonClassicalPydanticTypes,
+)
 from classiq.interface.model.classical_parameter_declaration import (
-    ClassicalParameterDeclaration,
+    AnonClassicalParameterDeclaration,
 )
-from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.quantum_function_call import (
     ArgValue,
-    OperandIdentifier,
     QuantumFunctionCall,
 )
 from classiq.interface.model.quantum_function_declaration import (
-    PositionalArg,
+    AnonPositionalArg,
+    AnonQuantumFunctionDeclaration,
+    AnonQuantumOperandDeclaration,
     QuantumFunctionDeclaration,
-    QuantumOperandDeclaration,
 )
 from classiq.interface.model.quantum_lambda_function import (
+    OperandIdentifier,
+    QuantumCallable,
     QuantumLambdaFunction,
-    QuantumOperand,
 )
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.quantum_type import QuantumType
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
+from classiq.interface.source_reference import SourceReference
 
-from classiq.exceptions import ClassiqValueError
+from classiq.qmod.generative import generative_mode_context, is_generative_mode
 from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
 from classiq.qmod.qmod_constant import QConstant
-from classiq.qmod.qmod_parameter import QParam, QParamScalar, create_param
-from classiq.qmod.qmod_variable import QVar, create_qvar_for_port_decl
+from classiq.qmod.qmod_parameter import (
+    CInt,
+    CParam,
+    CParamScalar,
+    create_param,
+    get_qmod_type,
+)
+from classiq.qmod.qmod_variable import (
+    QVar,
+    create_qvar_for_port_decl,
+)
 from classiq.qmod.quantum_callable import QCallable, QExpandableInterface
-from classiq.qmod.utilities import mangle_keyword
+from classiq.qmod.symbolic_expr import SymbolicExpr
+from classiq.qmod.type_attribute_remover import decl_without_type_attributes
+from classiq.qmod.utilities import mangle_keyword, qmod_val_to_expr_str
 
-ArgType = Union[QParam, QVar, QCallable]
+ArgType = Union[CParam, QVar, QCallable]
 
 
 class QExpandable(QCallable, QExpandableInterface, ABC):
-    STACK: ClassVar[List["QExpandable"]] = list()
+    STACK: ClassVar[list["QExpandable"]] = list()
 
     def __init__(self, py_callable: Callable) -> None:
         self._qmodule: ModelStateContainer = QMODULE
         self._py_callable: Callable = py_callable
-        self._body: List[QuantumStatement] = list()
+        self._body: list[QuantumStatement] = list()
 
     @property
-    def body(self) -> List[QuantumStatement]:
+    def body(self) -> list[QuantumStatement]:
         return self._body
 
     def __enter__(self) -> Self:
@@ -73,7 +92,7 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
 
     def __exit__(
         self,
-        exc_type: Optional[Type[BaseException]],
+        exc_type: Optional[type[BaseException]],
         exc_val: Optional[BaseException],
         exc_tb: Optional[TracebackType],
     ) -> None:
@@ -82,156 +101,303 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
             QExpandable.STACK[-1] if QExpandable.STACK else None
         )
 
+    def __call__(self, *args: Any, **kwargs: Any) -> None:
+        super().__call__(*args, **kwargs)
+        self.add_function_dependencies()
+
     def expand(self) -> None:
-        with self:
-            self._py_callable(*self._get_positional_args())
+        if self not in QExpandable.STACK:
+            with self, generative_mode_context(False):
+                self._py_callable(*self._get_positional_args())
 
-    def infer_rename_params(self) -> Dict[str, str]:
-        return {}
+    def infer_rename_params(self) -> Optional[list[str]]:
+        return None
 
-    def add_local_handle(self, name: str, qtype: QuantumType) -> None:
-        self._body.append(VariableDeclarationStatement(name=name, quantum_type=qtype))
+    def add_local_handle(
+        self,
+        name: str,
+        qtype: QuantumType,
+        source_ref: Optional[SourceReference] = None,
+    ) -> None:
+        self.append_statement_to_body(
+            VariableDeclarationStatement(
+                name=name, quantum_type=qtype, source_ref=source_ref
+            )
+        )
 
     def append_statement_to_body(self, stmt: QuantumStatement) -> None:
         self._body.append(stmt)
 
-    def _get_positional_args(self) -> List[ArgType]:
-        result: List[ArgType] = []
-        for arg in self.func_decl.get_positional_arg_decls():
-            if isinstance(arg, ClassicalParameterDeclaration):
-                rename_dict = self.infer_rename_params()
-                actual_name = rename_dict.get(arg.name, arg.name)
+    def _get_positional_args(self) -> list[ArgType]:
+        result: list[ArgType] = []
+        rename_params = self.infer_rename_params()
+        if rename_params is not None and len(rename_params) != len(
+            self.func_decl.positional_arg_declarations
+        ):
+            op_name = (
+                f" {self.func_decl.name!r}" if self.func_decl.name is not None else ""
+            )
+            raise ClassiqValueError(
+                f"Operand{op_name} takes {len(self.func_decl.positional_arg_declarations)} arguments but the received function takes {len(rename_params)} argument"
+            )
+        for idx, arg in enumerate(self.func_decl.positional_arg_declarations):
+            actual_name = (
+                rename_params[idx] if rename_params is not None else arg.get_name()
+            )
+            if isinstance(arg, AnonClassicalParameterDeclaration):
                 result.append(
                     create_param(actual_name, arg.classical_type, self._qmodule)
                 )
-            elif isinstance(arg, PortDeclaration):
-                result.append(create_qvar_for_port_decl(arg))
+            elif isinstance(arg, AnonPortDeclaration):
+                result.append(create_qvar_for_port_decl(arg, actual_name))
             else:
-                assert isinstance(arg, QuantumOperandDeclaration)
-                result.append(QTerminalCallable(arg))
+                assert isinstance(arg, AnonQuantumOperandDeclaration)
+                result.append(QTerminalCallable(arg, idx))
         return result
 
     def create_quantum_function_call(
-        self, *args: Any, **kwargs: Any
+        self, source_ref_: SourceReference, *args: Any, **kwargs: Any
     ) -> QuantumFunctionCall:
-        return _create_quantum_function_call(self.func_decl, None, *args, **kwargs)
+        func_decl = self.func_decl
+        if not isinstance(func_decl, QuantumFunctionDeclaration):
+            raise NotImplementedError
+        return _create_quantum_function_call(
+            func_decl, None, source_ref_, *args, **kwargs
+        )
+
+    def add_function_dependencies(self) -> None:
+        called_name = self.func_decl.name
+        if called_name is None:
+            return
+        for expandable in QExpandable.STACK:
+            caller_name = expandable.func_decl.name
+            if caller_name is not None:
+                caller_deps = self._qmodule.function_dependencies[caller_name]
+                if called_name not in caller_deps:
+                    caller_deps.append(called_name)
 
 
 class QLambdaFunction(QExpandable):
-    def __init__(self, decl: QuantumFunctionDeclaration, py_callable: Callable) -> None:
+    def __init__(
+        self, decl: AnonQuantumFunctionDeclaration, py_callable: Callable
+    ) -> None:
         py_callable.__annotations__.pop("return", None)
         super().__init__(py_callable)
         self._decl = decl
 
     @property
-    def func_decl(self) -> QuantumFunctionDeclaration:
+    def func_decl(self) -> AnonQuantumFunctionDeclaration:
         return self._decl
 
-    def infer_rename_params(self) -> Dict[str, str]:
-        py_params = inspect.getfullargspec(self._py_callable)
-        decl_params = self.func_decl.param_decls.keys()
-        return {
-            decl_param: py_param
-            for decl_param, py_param in zip(decl_params, py_params.args)
-            if decl_param != py_param
-        }
+    def expand(self) -> None:
+        if not is_generative_mode():
+            super().expand()
+
+    def infer_rename_params(self) -> list[str]:
+        return inspect.getfullargspec(self._py_callable).args
 
 
 class QTerminalCallable(QCallable):
+    @overload
     def __init__(
         self,
         decl: QuantumFunctionDeclaration,
-        index_: Optional[Union[int, QParamScalar]] = None,
+        param_idx: Optional[int] = None,
+        index_: Optional[Union[int, CParamScalar]] = None,
     ) -> None:
-        self._decl = decl
+        pass
+
+    @overload
+    def __init__(
+        self,
+        decl: AnonQuantumFunctionDeclaration,
+        param_idx: int,
+        index_: Optional[Union[int, CParamScalar]] = None,
+    ) -> None:
+        pass
+
+    def __init__(
+        self,
+        decl: AnonQuantumFunctionDeclaration,
+        param_idx: Optional[int] = None,
+        index_: Optional[Union[int, CParamScalar]] = None,
+    ) -> None:
+        self._decl = self._override_decl_name(decl, param_idx)
         self._index = index_
 
+    @staticmethod
+    def _override_decl_name(
+        decl: AnonQuantumFunctionDeclaration, param_idx: Optional[int]
+    ) -> QuantumFunctionDeclaration:
+        if (
+            not isinstance(QCallable.CURRENT_EXPANDABLE, QLambdaFunction)
+            or param_idx is None
+        ):
+            return decl.rename(decl.get_name())
+        rename_params = QCallable.CURRENT_EXPANDABLE.infer_rename_params()
+        return decl.rename(new_name=rename_params[param_idx])
+
     @property
     def is_list(self) -> bool:
-        return isinstance(self._decl, QuantumOperandDeclaration) and self._decl.is_list
+        return (
+            isinstance(self._decl, AnonQuantumOperandDeclaration) and self._decl.is_list
+        )
 
-    def __getitem__(self, key: Union[slice, int, QParam]) -> "QTerminalCallable":
+    def __getitem__(self, key: Union[slice, int, CInt]) -> "QTerminalCallable":
         if not self.is_list:
             raise ClassiqValueError("Cannot index a non-list operand")
         if isinstance(key, slice):
             raise NotImplementedError("Operand lists don't support slicing")
-        if isinstance(key, QParam) and not isinstance(key, QParamScalar):
+        if isinstance(key, CParam) and not isinstance(key, CParamScalar):
             raise ClassiqValueError("Non-classical parameter for slicing")
-        return QTerminalCallable(self._decl, key)
+        if not isinstance(self._decl, AnonQuantumOperandDeclaration):
+            raise ClassiqInternalError
+        return QTerminalCallable(self._decl.element_declaration, index_=key)
 
     def __len__(self) -> int:
         raise ClassiqValueError(
-            "len(<func>) is not supported for quantum callables - use <func>.len() instead (Only if it is an operand list)"
+            "len(<func>) is not supported for quantum callables - use <func>.len instead (Only if it is an operand list)"
         )
 
     if TYPE_CHECKING:
 
+        @property
         def len(self) -> int: ...
 
     else:
 
-        def len(self) -> QParamScalar:
+        @property
+        def len(self) -> CParamScalar:
             if not self.is_list:
                 raise ClassiqValueError("Cannot get length of a non-list operand")
-            return QParamScalar(f"len({self.func_decl.name})")
+            return CParamScalar(f"get_field({self.func_decl.name}, 'len')")
 
     @property
     def func_decl(self) -> QuantumFunctionDeclaration:
         return self._decl
 
     def create_quantum_function_call(
-        self, *args: Any, **kwargs: Any
+        self, source_ref_: SourceReference, *args: Any, **kwargs: Any
     ) -> QuantumFunctionCall:
         if self.is_list and self._index is None:
             raise ClassiqValueError(
                 f"Quantum operand {self.func_decl.name!r} is a list and must be indexed"
             )
         return _create_quantum_function_call(
-            self.func_decl, self._index, *args, **kwargs
+            self.func_decl, self._index, source_ref_, *args, **kwargs
+        )
+
+    def get_arg(self) -> QuantumCallable:
+        if self._index is None:
+            return self._decl.name
+        return OperandIdentifier(
+            name=self._decl.name, index=Expression(expr=str(self._index))
         )
 
 
 @overload
 def prepare_arg(
-    arg_decl: PositionalArg, val: Union[QCallable, Callable[[Any], None]]
-) -> QuantumOperand: ...
+    arg_decl: AnonPositionalArg,
+    val: Union[QCallable, Callable[..., None]],
+    func_name: Optional[str],
+    param_name: str,
+) -> QuantumLambdaFunction: ...
 
 
 @overload
-def prepare_arg(arg_decl: PositionalArg, val: Any) -> ArgValue: ...
+def prepare_arg(
+    arg_decl: AnonPositionalArg, val: Any, func_name: Optional[str], param_name: str
+) -> ArgValue: ...
 
 
-def prepare_arg(arg_decl: PositionalArg, val: Any) -> ArgValue:
+def prepare_arg(
+    arg_decl: AnonPositionalArg, val: Any, func_name: Optional[str], param_name: str
+) -> ArgValue:
+    from classiq.qmod.quantum_function import BaseQFunc, GenerativeQFunc
+
+    if isinstance(val, BaseQFunc):
+        val.add_function_dependencies()
+    if isinstance(val, GenerativeQFunc):
+        QMODULE.generative_functions[val.func_decl.name] = val
     if isinstance(val, QConstant):
         val.add_to_model()
         return Expression(expr=str(val.name))
-    if isinstance(arg_decl, ClassicalParameterDeclaration):
-        return Expression(expr=str(val))
-    elif isinstance(arg_decl, PortDeclaration):
+    if isinstance(arg_decl, AnonClassicalParameterDeclaration):
+        _validate_classical_arg(val, arg_decl, func_name)
+        return Expression(expr=qmod_val_to_expr_str(val))
+    elif isinstance(arg_decl, AnonPortDeclaration):
+        if not isinstance(val, QVar):
+            func_name_message = (
+                "" if func_name is None else f" of function {func_name!r}"
+            )
+            raise ClassiqValueError(
+                f"Argument {str(val)!r} to parameter {param_name!r}{func_name_message} "
+                f"has incompatible type; expected quantum variable"
+            )
         return val.get_handle_binding()
     else:
         if isinstance(val, list):
             if not all(isinstance(v, QCallable) or callable(v) for v in val):
                 raise ClassiqValueError(
-                    f"Quantum operand {arg_decl.name!r} cannot be initialized with a list of non-callables"
+                    f"Quantum operand {param_name!r} cannot be initialized with a "
+                    f"list of non-callables"
                 )
-            val = cast(List[Union[QCallable, Callable[[Any], None]]], val)
-            return [prepare_arg(arg_decl, v) for v in val]
+            val = cast(list[Union[QCallable, Callable[[Any], None]]], val)
+            return [prepare_arg(arg_decl, v, func_name, param_name) for v in val]
 
         if not isinstance(val, QCallable):
-            val = QLambdaFunction(arg_decl, val)
-
-        if not isinstance(val, QExpandable):
-            return val.func_decl.name
-
-        val.expand()
-        return QuantumLambdaFunction(
-            rename_params=val.infer_rename_params(), body=val.body
+            if not callable(val):
+                raise ClassiqValueError(
+                    f"Operand argument to {param_name!r} must be a callable object"
+                )
+            new_arg_decl = decl_without_type_attributes(arg_decl)
+            val = QLambdaFunction(new_arg_decl, val)
+            val.expand()
+            qlambda = QuantumLambdaFunction(
+                pos_rename_params=val.infer_rename_params(),
+                body=val.body,
+            )
+            if is_generative_mode():
+                qlambda.set_py_callable(val._py_callable)
+            return qlambda
+
+        if isinstance(val, QExpandable):
+            val.expand()
+        elif isinstance(val, QTerminalCallable):
+            return val.get_arg()
+        return val.func_decl.name
+
+
+def _validate_classical_arg(
+    arg: Any, arg_decl: AnonClassicalParameterDeclaration, func_name: Optional[str]
+) -> None:
+    is_native_or_compatible_type = not isinstance(
+        arg, (*NativePythonClassicalTypes, CParam, SymbolicExpr, Basic, PythonEnum)
+    ) and not is_dataclass(
+        arg
+    )  # type: ignore[unreachable]
+    try:
+        is_pydantic_classical_type = isinstance(
+            arg, pydantic.BaseModel
+        ) and not isinstance(arg, PythonClassicalPydanticTypes)
+    except ClassiqValueError:
+        is_pydantic_classical_type = False
+
+    is_incompatible_symbolic_expr = isinstance(arg, SymbolicExpr) and arg.is_quantum
+
+    if (
+        is_native_or_compatible_type or is_pydantic_classical_type
+    ) or is_incompatible_symbolic_expr:
+        func_name_message = f" of function {func_name!r}" if func_name else ""
+        raise ClassiqValueError(
+            f"Argument {str(arg)!r} to parameter {arg_decl.name!r}{func_name_message} "
+            f"has incompatible type; expected "
+            f"{get_qmod_type(arg_decl.classical_type).__name__}"
         )
 
 
 def _get_operand_hint_args(
-    func: QuantumFunctionDeclaration, param: PositionalArg, param_value: str
+    func: AnonQuantumFunctionDeclaration, param: AnonPositionalArg, param_value: str
 ) -> str:
     return ", ".join(
         [
@@ -240,50 +406,55 @@ def _get_operand_hint_args(
                 if decl.name == param.name
                 else f"{decl.name}=..."
             )
-            for decl in func.get_positional_arg_decls()
+            for decl in func.positional_arg_declarations
         ]
     )
 
 
-def _get_operand_hint(func: QuantumFunctionDeclaration, param: PositionalArg) -> str:
+def _get_operand_hint(
+    func: AnonQuantumFunctionDeclaration, param: AnonPositionalArg
+) -> str:
     return (
-        f"\nHint: To create an operand, do not call quantum gates directly "
-        f"`{func.name}({_get_operand_hint_args(func, param, 'H(q)')})`. "
-        f"Instead, use a lambda function "
-        f"`{func.name}({_get_operand_hint_args(func, param, 'lambda: H(q)')})` "
-        f"or a quantum function "
-        f"`{func.name}({_get_operand_hint_args(func, param, 'my_func')})`"
+        f"\nHint: To call a function under {func.name!r} use a lambda function as in "
+        f"'{func.name}({_get_operand_hint_args(func, param, 'lambda: f(q)')})' "
+        f"or pass the quantum function directly as in "
+        f"'{func.name}({_get_operand_hint_args(func, param, 'f')})'."
     )
 
 
 def _prepare_args(
-    decl: QuantumFunctionDeclaration, arg_list: List[Any], kwargs: Dict[str, Any]
-) -> List[ArgValue]:
+    decl: AnonQuantumFunctionDeclaration, arg_list: list[Any], kwargs: dict[str, Any]
+) -> list[ArgValue]:
     result = []
-    for arg_decl in decl.get_positional_arg_decls():
+    for idx, arg_decl in enumerate(decl.positional_arg_declarations):
+        arg = None
         if arg_list:
             arg = arg_list.pop(0)
-        else:
+        elif arg_decl.name is not None:
             arg = kwargs.pop(mangle_keyword(arg_decl.name), None)
         if arg is None:
-            error_message = (
-                f"{decl.name!r} is missing required argument for {arg_decl.name!r}"
-            )
-            if isinstance(arg_decl, QuantumOperandDeclaration):
+            if arg_decl.name is not None:
+                param_name = repr(arg_decl.name)
+            else:
+                param_name = f"#{idx + 1}"
+            error_message = f"Missing required argument for parameter {param_name}"
+            if isinstance(arg_decl, AnonQuantumOperandDeclaration):
                 error_message += _get_operand_hint(decl, arg_decl)
             raise ClassiqValueError(error_message)
-        result.append(prepare_arg(arg_decl, arg))
+        param_name = arg_decl.name if arg_decl.name is not None else f"#{idx + 1}"
+        result.append(prepare_arg(arg_decl, arg, decl.name, param_name))
 
     return result
 
 
 def _create_quantum_function_call(
     decl_: QuantumFunctionDeclaration,
-    index_: Optional[Union[QParamScalar, int]] = None,
+    index_: Optional[Union[CParamScalar, int]] = None,
+    source_ref_: Optional[SourceReference] = None,
     *args: Any,
     **kwargs: Any,
 ) -> QuantumFunctionCall:
-    arg_decls = decl_.get_positional_arg_decls()
+    arg_decls = decl_.positional_arg_declarations
     arg_list = list(args)
     prepared_args = _prepare_args(decl_, arg_list, kwargs)
 
@@ -307,4 +478,6 @@ def _create_quantum_function_call(
             index=Expression(expr=str(index_)), name=function_ident
         )
 
-    return QuantumFunctionCall(function=function_ident, positional_args=prepared_args)
+    return QuantumFunctionCall(
+        function=function_ident, positional_args=prepared_args, source_ref=source_ref_
+    )