classiq 0.37.1__py3-none-any.whl → 0.65.3__py3-none-any.whl

classiq/qmod/qfunc.py

@@ -0,0 +1,79 @@
+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 (
+    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) -> QFunc: ...
+
+
+@overload
+def qfunc(
+    *,
+    external: Literal[True],
+    synthesize_separately: Literal[False] = False,
+) -> Callable[[Callable], ExternalQFunc]: ...
+
+
+@overload
+def qfunc(
+    *,
+    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:
+        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)
+        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)
+
+    return wrapper

classiq/qmod/qmod_constant.py

@@ -0,0 +1,143 @@
+import inspect
+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 (
+    ClassicalArray,
+    ClassicalList,
+)
+
+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 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(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
+
+    @staticmethod
+    def set_current_model(qmodule: ModelStateContainer) -> None:
+        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(QMODULE_ERROR_MESSAGE)
+
+        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):
+            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),
+            )
+
+        qmod_type = python_type_to_qmod(
+            self._py_type, qmodule=QConstant.CURRENT_QMODULE
+        )
+        if qmod_type is None:
+            raise ClassiqError("Invalid QMOD type")
+
+        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 is_dataclass(py_type)
+        ):
+            return self.__getattribute__(name)
+
+        return CParamStruct.get_field(
+            QConstant.CURRENT_QMODULE, self.name, py_type.__name__, 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,33 +1,38 @@
-import sys
-from typing import _GenericAlias  # type: ignore[attr-defined]
-from typing import Any, Generic, TypeVar, Union
-
-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")
-
-
-class QParam(Symbolic, Generic[_T]):
-    pass
+if TYPE_CHECKING:
 
+    SymbolicSuperclass = SymbolicExpr
+else:
+    SymbolicSuperclass = Symbolic
 
-class QParamScalar(QParam, SymbolicExpr):
-    pass
 
-
-class QParamList(QParam):
+class CParamList(CParam):
     def __init__(
         self,
         expr: str,
@@ -38,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 ValueError(
-            "len(<expr>) is not supported for QMod lists - use <expr>.len() instead"
+        raise ClassiqValueError(
+            "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:
@@ -62,47 +77,63 @@ class QParamStruct(QParam):
         self._qmodule = qmodule
         self._struct_type = struct_type
 
-    def __getattr__(self, field_name: str) -> QParam:
-        struct_decl = StructDeclaration.BUILTIN_STRUCT_DECLARATIONS.get(
-            self._struct_type.name
+    def __getattr__(self, field_name: str) -> CParam:
+        return CParamStruct.get_field(
+            self._qmodule, str(self), self._struct_type.name, field_name
+        )
+
+    @staticmethod
+    def get_field(
+        qmodule: ModelStateContainer,
+        variable_name: str,
+        struct_name: str,
+        field_name: str,
+    ) -> CParam:
+        struct_decl = BUILTIN_STRUCT_DECLARATIONS.get(
+            struct_name, qmodule.type_decls.get(struct_name)
         )
-        if struct_decl is None:
-            struct_decl = self._qmodule.type_decls.get(self._struct_type.name)
         assert struct_decl is not None
         field_type = struct_decl.variables.get(field_name)
         if field_type is None:
             raise ClassiqValueError(
-                f"Struct {self._struct_type.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(
-            f"get_field({self},{field_name!r})",
+            f"get_field({variable_name},{field_name!r})",
             field_type,
-            qmodule=self._qmodule,
+            qmodule=qmodule,
         )
 
 
-_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:
-    if isinstance(ctype, ClassicalList) or isinstance(ctype, ClassicalArray):
-        return QParamList(expr_str, ctype, qmodule=qmodule)
+) -> CParam:
+    if isinstance(ctype, (ClassicalList, ClassicalArray)):
+        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"
+    )