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

classiq/qmod/qfunc.py

@@ -1,25 +1,77 @@
-from typing import Callable, Optional, Union, overload
+from collections.abc import Iterator
+from contextlib import contextmanager
+from typing import Callable, Literal, Optional, Union, overload
+
+from classiq.interface.exceptions import ClassiqInternalError
 
 from classiq.qmod.quantum_callable import QCallable
-from classiq.qmod.quantum_function import ExternalQFunc, QFunc
+from classiq.qmod.quantum_function import (
+    BaseQFunc,
+    ExternalQFunc,
+    GenerativeQFunc,
+    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, *, external: bool = False) -> QFunc: ...
+def qfunc(func: Callable) -> QFunc: ...
 
 
 @overload
-def qfunc(func: None = None, *, external: bool) -> Callable[[Callable], QCallable]: ...
+def qfunc(
+    *,
+    external: Literal[True],
+    synthesize_separately: Literal[False] = False,
+) -> Callable[[Callable], ExternalQFunc]: ...
 
 
+@overload
 def qfunc(
-    func: Optional[Callable] = None, *, external: bool = False
+    *,
+    generative: Literal[True],
+    synthesize_separately: bool = False,
+) -> Callable[[Callable], GenerativeQFunc]: ...
+
+
+@overload
+def qfunc(*, synthesize_separately: bool) -> Callable[[Callable], QFunc]: ...
+
+
+def qfunc(
+    func: Optional[Callable] = None,
+    *,
+    external: bool = False,
+    generative: bool = False,
+    synthesize_separately: bool = False,
 ) -> Union[Callable[[Callable], QCallable], QCallable]:
     def wrapper(func: Callable) -> QCallable:
-        if external:
+        qfunc: BaseQFunc
+        if generative or _GENERATIVE_SWITCH:
+            qfunc = GenerativeQFunc(func)
+        elif external:
+            if synthesize_separately:
+                raise ClassiqInternalError(
+                    "External functions can't be marked as synthesized separately"
+                )
             return ExternalQFunc(func)
-
-        return QFunc(func)
+        else:
+            qfunc = QFunc(func)
+        if synthesize_separately:
+            qfunc.update_compilation_metadata(should_synthesize_separately=True)
+        return qfunc
 
     if func is not None:
         return wrapper(func)

classiq/qmod/qmod_constant.py

@@ -1,20 +1,37 @@
 import inspect
-from typing import Any, Optional
+from dataclasses import is_dataclass
+from typing import Any, Optional, cast, get_origin
 
+from classiq.interface.exceptions import ClassiqError, ClassiqValueError
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.classical_type import QStructBase
+from classiq.interface.generator.functions.classical_type import (
+    ClassicalArray,
+    ClassicalList,
+)
 
-from classiq.exceptions import ClassiqError
+from classiq.qmod.cparam import CArray, CParamScalar
 from classiq.qmod.declaration_inferrer import python_type_to_qmod
+from classiq.qmod.generative import (
+    get_frontend_interpreter,
+    interpret_expression,
+    is_generative_mode,
+)
 from classiq.qmod.model_state_container import ModelStateContainer
-from classiq.qmod.qmod_parameter import QParam, QParamStruct
+from classiq.qmod.qmod_parameter import CParam, CParamList, CParamStruct
+from classiq.qmod.symbolic_expr import SymbolicExpr
+from classiq.qmod.utilities import qmod_val_to_expr_str
 
+QMODULE_ERROR_MESSAGE = (
+    "Error trying to add a constant to a model without a current QModule."
+)
 
-class QConstant:
+
+class QConstant(SymbolicExpr):
     CURRENT_QMODULE: Optional[ModelStateContainer] = None
 
     def __init__(self, name: str, py_type: type, value: Any) -> None:
+        super().__init__(name, False)
         self.name = name
         self._py_type = py_type
         self._value = value
@@ -24,53 +41,103 @@ class QConstant:
         QConstant.CURRENT_QMODULE = qmodule
 
     def add_to_model(self) -> None:
+        from classiq.qmod.builtins.constants import __all__ as builtin_constants
+
+        if self.name in builtin_constants:
+            return
         if QConstant.CURRENT_QMODULE is None:
-            raise ClassiqError(
-                "Error trying to add a constant to a model without a current QModule."
-            )
+            raise ClassiqError(QMODULE_ERROR_MESSAGE)
 
-        expr = str(self._value)
+        expr = qmod_val_to_expr_str(self._value)
         if (
             self.name in QConstant.CURRENT_QMODULE.constants
             and expr != QConstant.CURRENT_QMODULE.constants[self.name].value.expr
         ):
             raise ClassiqError(f"Constant {self.name} is already defined in the model")
 
+        constant = self._get_constant_node()
+        QConstant.CURRENT_QMODULE.constants[self.name] = constant
+        if is_generative_mode():
+            get_frontend_interpreter().add_constant(constant)
+
+    def _get_constant_node(self) -> Constant:
         if isinstance(self._value, QConstant):
-            QConstant.CURRENT_QMODULE.constants[self.name] = Constant(
+            if QConstant.CURRENT_QMODULE is None:
+                raise ClassiqError(QMODULE_ERROR_MESSAGE)
+            return Constant(
                 name=self.name,
                 const_type=QConstant.CURRENT_QMODULE.constants[
                     self._value.name
                 ].const_type,
                 value=Expression(expr=self._value.name),
             )
-        else:
-            qmod_type = python_type_to_qmod(
-                self._py_type, qmodule=QConstant.CURRENT_QMODULE
-            )
-            if qmod_type is None:
-                raise ClassiqError("Invalid QMOD type")
 
-            QConstant.CURRENT_QMODULE.constants[self.name] = Constant(
-                name=self.name,
-                const_type=qmod_type,
-                value=Expression(expr=expr),
-            )
+        qmod_type = python_type_to_qmod(
+            self._py_type, qmodule=QConstant.CURRENT_QMODULE
+        )
+        if qmod_type is None:
+            raise ClassiqError("Invalid QMOD type")
 
-    def __getattr__(self, name: str) -> QParam:
+        expr = qmod_val_to_expr_str(self._value)
+        return Constant(
+            name=self.name,
+            const_type=qmod_type,
+            value=Expression(expr=expr),
+        )
+
+    def __getattr__(self, name: str) -> CParam:
         self.add_to_model()
 
+        if name == "is_quantum":
+            return False  # type:ignore[return-value]
+
         py_type = type(self._value)
         if (
             QConstant.CURRENT_QMODULE is None
             or not inspect.isclass(py_type)
-            or not issubclass(py_type, QStructBase)
+            or not is_dataclass(py_type)
         ):
             return self.__getattribute__(name)
 
-        return QParamStruct.get_field(
+        return CParamStruct.get_field(
             QConstant.CURRENT_QMODULE, self.name, py_type.__name__, name
         )
 
-    def __str__(self) -> str:
-        return self.name
+    def __getitem__(self, item: Any) -> CParam:
+        self.add_to_model()
+
+        assert QConstant.CURRENT_QMODULE is not None
+
+        qmod_type = python_type_to_qmod(
+            self._py_type, qmodule=QConstant.CURRENT_QMODULE
+        )
+        if qmod_type is None:
+            raise ClassiqError("Invalid QMOD type")
+
+        if not isinstance(qmod_type, (ClassicalList, ClassicalArray)):
+            raise ClassiqError("Invalid subscript to non-list constant")
+
+        return CParamList(
+            self.name,
+            qmod_type,
+            QConstant.CURRENT_QMODULE,
+        )[item]
+
+    def __len__(self) -> int:
+        raise ClassiqValueError(
+            "len(<const>) is not supported for classical constants - use <const>.len "
+            "instead"
+        )
+
+    @property
+    def len(self) -> int:
+        self.add_to_model()
+        if get_origin(self._py_type) != CArray:
+            raise ClassiqValueError(
+                f"Constant {self.name!r} of type {self._py_type.__name__!r} does not "
+                f"have a 'len' property"
+            )
+        len_expr = f"get_field({self.name}, 'len')"
+        if is_generative_mode():
+            return interpret_expression(len_expr)
+        return cast(int, CParamScalar(len_expr))

classiq/qmod/qmod_parameter.py

@@ -1,46 +1,38 @@
-import sys
-from typing import (  # type: ignore[attr-defined]
-    TYPE_CHECKING,
-    Any,
-    Generic,
-    TypeVar,
-    Union,
-    _GenericAlias,
-)
-
-from typing_extensions import ParamSpec
+from typing import TYPE_CHECKING, Any, Union
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.functions.classical_type import (
+    Bool,
     ClassicalArray,
     ClassicalList,
     ClassicalType,
-    Struct,
+    Integer,
+    Real,
+)
+from classiq.interface.generator.functions.type_name import Struct, TypeName
+
+from classiq.qmod.builtins.structs import BUILTIN_STRUCT_DECLARATIONS
+from classiq.qmod.cparam import (  # noqa: F401
+    Array,
+    ArrayBase,
+    CArray,
+    CBool,
+    CInt,
+    CParam,
+    CParamScalar,
+    CReal,
 )
-
-from classiq import StructDeclaration
-from classiq.exceptions import ClassiqValueError
 from classiq.qmod.model_state_container import ModelStateContainer
 from classiq.qmod.symbolic_expr import Symbolic, SymbolicExpr
 
-_T = TypeVar("_T")
-
-
 if TYPE_CHECKING:
 
-    class QParam(SymbolicExpr, Generic[_T]):
-        pass
-
+    SymbolicSuperclass = SymbolicExpr
 else:
+    SymbolicSuperclass = Symbolic
 
-    class QParam(Symbolic, Generic[_T]):
-        pass
-
-
-class QParamScalar(QParam, SymbolicExpr):
-    pass
 
-
-class QParamList(QParam):
+class CParamList(CParam):
     def __init__(
         self,
         expr: str,
@@ -51,23 +43,33 @@ class QParamList(QParam):
         self._qmodule = qmodule
         self._list_type = list_type
 
-    def __getitem__(self, key: Any) -> QParam:
+    def __getitem__(self, key: Any) -> CParam:
+        param_type = self._list_type.element_type
+        if isinstance(key, slice):
+            param_type = self._list_type
+            start = key.start if key.start is not None else ""
+            stop = key.stop if key.stop is not None else ""
+            if key.step is not None:
+                key = f"{start}:{key.step}:{stop}"
+            else:
+                key = f"{start}:{stop}"
         return create_param(
             f"({self})[{key}]",
-            self._list_type.element_type,
+            param_type,
             qmodule=self._qmodule,
         )
 
     def __len__(self) -> int:
         raise ClassiqValueError(
-            "len(<expr>) is not supported for QMod lists - use <expr>.len() instead"
+            "len(<expr>) is not supported for QMod lists - use <expr>.len instead"
         )
 
-    def len(self) -> QParamScalar:
-        return QParamScalar(f"len({self})")
+    @property
+    def len(self) -> CParamScalar:
+        return CParamScalar(f"get_field({self}, 'len')")
 
 
-class QParamStruct(QParam):
+class CParamStruct(CParam):
     def __init__(
         self, expr: str, struct_type: Struct, *, qmodule: ModelStateContainer
     ) -> None:
@@ -75,8 +77,8 @@ class QParamStruct(QParam):
         self._qmodule = qmodule
         self._struct_type = struct_type
 
-    def __getattr__(self, field_name: str) -> QParam:
-        return QParamStruct.get_field(
+    def __getattr__(self, field_name: str) -> CParam:
+        return CParamStruct.get_field(
             self._qmodule, str(self), self._struct_type.name, field_name
         )
 
@@ -86,15 +88,16 @@ class QParamStruct(QParam):
         variable_name: str,
         struct_name: str,
         field_name: str,
-    ) -> QParam:
-        struct_decl = StructDeclaration.BUILTIN_STRUCT_DECLARATIONS.get(
+    ) -> CParam:
+        struct_decl = BUILTIN_STRUCT_DECLARATIONS.get(
             struct_name, qmodule.type_decls.get(struct_name)
         )
         assert struct_decl is not None
         field_type = struct_decl.variables.get(field_name)
         if field_type is None:
             raise ClassiqValueError(
-                f"Struct {struct_name!r} doesn't have field {field_name!r}"
+                f"{struct_name} {variable_name!r} has no field {field_name!r}. "
+                f"Available fields: {', '.join(struct_decl.variables.keys())}"
             )
 
         return create_param(
@@ -104,27 +107,33 @@ class QParamStruct(QParam):
         )
 
 
-_P = ParamSpec("_P")
-
-
-class ArrayBase(Generic[_P]):
-    # Support comma-separated generic args in older Python versions
-    if sys.version_info[0:2] < (3, 10):
-
-        def __class_getitem__(cls, args) -> _GenericAlias:
-            return _GenericAlias(cls, args)
-
-
-class Array(ArrayBase[_P]):
-    pass
-
-
 def create_param(
     expr_str: str, ctype: ClassicalType, qmodule: ModelStateContainer
-) -> QParam:
+) -> CParam:
     if isinstance(ctype, (ClassicalList, ClassicalArray)):
-        return QParamList(expr_str, ctype, qmodule=qmodule)
+        return CParamList(expr_str, ctype, qmodule=qmodule)
     elif isinstance(ctype, Struct):
-        return QParamStruct(expr_str, ctype, qmodule=qmodule)
+        return CParamStruct(expr_str, ctype, qmodule=qmodule)
     else:
-        return QParamScalar(expr_str)
+        return CParamScalar(expr_str)
+
+
+def get_qmod_type(ctype: ClassicalType) -> type:
+    if isinstance(ctype, Integer):
+        return CInt
+    elif isinstance(ctype, Real):
+        return CReal
+    elif isinstance(ctype, Bool):
+        return CBool
+    elif isinstance(ctype, ClassicalList):
+        return CArray[get_qmod_type(ctype.element_type)]  # type: ignore[misc]
+    elif isinstance(ctype, ClassicalArray):
+        return CArray[get_qmod_type(ctype.element_type), ctype.size]  # type: ignore[misc]
+    elif isinstance(ctype, TypeName):
+        type_ = type(ctype.name, (TypeName,), dict())
+        if isinstance(ctype, Struct):
+            type_.__dataclass_fields__ = []  # type:ignore[attr-defined]
+        return type_
+    raise NotImplementedError(
+        f"{ctype.__class__.__name__!r} has no QMOD SDK equivalent"
+    )