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

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)

classiq/qmod/qmod_variable.py

@@ -103,6 +103,9 @@ def _infer_variable_name(name: Any, depth: int) -> Any:
     return name
 
 
+_SYMBOLIC_TYPES = tuple(get_origin(t) or t for t in get_args(SymbolicTypes))
+
+
 class QVar(Symbolic):
     CONSTRUCTOR_DEPTH: int = 1
 
@@ -218,7 +221,7 @@ class QScalar(QVar, SymbolicExpr):
         )
 
     def __ior__(self, other: Any) -> Self:
-        if not isinstance(other, get_args(SymbolicTypes)):
+        if not isinstance(other, _SYMBOLIC_TYPES):
             raise TypeError(
                 f"Invalid argument {other!r} for out-of-place arithmetic operation"
             )
@@ -229,7 +232,7 @@ class QScalar(QVar, SymbolicExpr):
         return self
 
     def __ixor__(self, other: Any) -> Self:
-        if not isinstance(other, get_args(SymbolicTypes)):
+        if not isinstance(other, _SYMBOLIC_TYPES):
             raise TypeError(
                 f"Invalid argument {other!r} for in-place arithmetic operation"
             )
@@ -240,7 +243,7 @@ class QScalar(QVar, SymbolicExpr):
         return self
 
     def __iadd__(self, other: Any) -> Self:
-        if not isinstance(other, get_args(SymbolicTypes)):
+        if not isinstance(other, _SYMBOLIC_TYPES):
             raise TypeError(
                 f"Invalid argument {other!r} for in-place arithmetic operation"
             )
@@ -251,7 +254,7 @@ class QScalar(QVar, SymbolicExpr):
         return self
 
     def __imul__(self, other: Any) -> Self:
-        if not isinstance(other, get_args(SymbolicTypes)):
+        if not isinstance(other, _SYMBOLIC_TYPES):
             raise TypeError(
                 f"Invalid argument {other!r} for out of ampltiude encoding operation"
             )

classiq/qmod/quantum_expandable.py

@@ -28,6 +28,7 @@ from classiq.interface.generator.functions.concrete_types import (
 from classiq.interface.model.classical_parameter_declaration import (
     AnonClassicalParameterDeclaration,
 )
+from classiq.interface.model.handle_binding import GeneralHandle, HandlesList
 from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.quantum_function_call import (
     ArgValue,
@@ -52,6 +53,7 @@ from classiq.interface.model.variable_declaration_statement import (
 from classiq.interface.source_reference import SourceReference
 
 from classiq.qmod.generative import generative_mode_context, is_generative_mode
+from classiq.qmod.global_declarative_switch import get_global_declarative_switch
 from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
 from classiq.qmod.qmod_constant import QConstant
 from classiq.qmod.qmod_parameter import (
@@ -84,6 +86,11 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
         self._py_callable: Callable = py_callable
         self._body: list[QuantumStatement] = list()
 
+    def __eq__(self, other: Any) -> bool:
+        return (
+            isinstance(other, QExpandable) and self._py_callable is other._py_callable
+        )
+
     @property
     def body(self) -> list[QuantumStatement]:
         return self._body
@@ -317,8 +324,10 @@ def prepare_arg(
 def prepare_arg(
     arg_decl: AnonPositionalArg, val: Any, func_name: Optional[str], param_name: str
 ) -> ArgValue:
-    from classiq.qmod.quantum_function import BaseQFunc, GenerativeQFunc
+    from classiq.qmod.quantum_function import BaseQFunc, GenerativeQFunc, QFunc
 
+    if get_global_declarative_switch() and isinstance(val, GenerativeQFunc):
+        val = QFunc(val._py_callable)
     if isinstance(val, BaseQFunc):
         val.add_function_dependencies()
     if isinstance(val, GenerativeQFunc):
@@ -330,6 +339,9 @@ def prepare_arg(
         _validate_classical_arg(val, arg_decl, func_name)
         return Expression(expr=qmod_val_to_expr_str(val))
     elif isinstance(arg_decl, AnonPortDeclaration):
+        handles_list = _try_preparing_handles_list(val)
+        if handles_list is not None:
+            return handles_list
         if not isinstance(val, QVar):
             func_name_message = (
                 "" if func_name is None else f" of function {func_name!r}"
@@ -505,3 +517,19 @@ def _is_legal_iterable_element(arg: Any) -> bool:
     if isinstance(arg, Iterable):
         return all(_is_legal_iterable_element(e) for e in arg)
     return True
+
+
+def _try_preparing_handles_list(val: Any) -> Optional[HandlesList]:
+    if not isinstance(val, list):
+        return None
+    items = [
+        (
+            item.get_handle_binding()
+            if isinstance(item, QVar)
+            else _try_preparing_handles_list(item)
+        )
+        for item in val
+    ]
+    if any(item is None for item in items):
+        return None
+    return HandlesList(handles=cast(list[GeneralHandle], items))

classiq/qmod/quantum_function.py

@@ -26,6 +26,7 @@ from classiq.qmod.classical_function import CFunc
 from classiq.qmod.cparam import CParamAbstract
 from classiq.qmod.declaration_inferrer import infer_func_decl, is_qvar
 from classiq.qmod.generative import set_frontend_interpreter
+from classiq.qmod.global_declarative_switch import get_global_declarative_switch
 from classiq.qmod.qmod_constant import QConstant
 from classiq.qmod.qmod_parameter import CArray
 from classiq.qmod.quantum_callable import QCallable, QCallableList
@@ -49,6 +50,18 @@ class BaseQFunc(QExpandable):
     def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
         raise NotImplementedError
 
+    @property
+    def pure_decl(self) -> NamedParamsQuantumFunctionDeclaration:
+        if type(self.func_decl) is NamedParamsQuantumFunctionDeclaration:
+            return self.func_decl
+        return NamedParamsQuantumFunctionDeclaration(
+            **{
+                k: v
+                for k, v in self.func_decl.model_dump().items()
+                if k in NamedParamsQuantumFunctionDeclaration.model_fields
+            }
+        )
+
     @property
     def _has_inputs(self) -> bool:
         return any(
@@ -90,18 +103,6 @@ class QFunc(BaseQFunc):
         super().__init__(py_callable, compilation_metadata)
         self.compilation_metadata: Optional[CompilationMetadata] = None
 
-    @property
-    def pure_decl(self) -> NamedParamsQuantumFunctionDeclaration:
-        if type(self.func_decl) is NamedParamsQuantumFunctionDeclaration:
-            return self.func_decl
-        return NamedParamsQuantumFunctionDeclaration(
-            **{
-                k: v
-                for k, v in self.func_decl.model_dump().items()
-                if k in NamedParamsQuantumFunctionDeclaration.model_fields
-            }
-        )
-
     @property
     def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
         name = self._py_callable.__name__
@@ -142,7 +143,10 @@ class QFunc(BaseQFunc):
             functions_compilation_metadata=self._qmodule.functions_compilation_metadata,
             **{key: value for key, value in model_extra_settings if value},
         )
-        if len(self._qmodule.generative_functions) > 0:
+        if (
+            not get_global_declarative_switch()
+            and len(self._qmodule.generative_functions) > 0
+        ):
             return self._create_generative_model(model)
         return model
 
@@ -233,12 +237,6 @@ class ExternalQFunc(QTerminalCallable):
     def pure_decl(self) -> NamedParamsQuantumFunctionDeclaration:
         return self.func_decl
 
-    def get_implementation(self) -> NativeFunctionDefinition:
-        model = QFunc(self._py_callable).create_model()
-        return [
-            func for func in model.functions if func.name == self._py_callable.__name__
-        ][0]
-
 
 class GenerativeQFunc(BaseQFunc):
     FRAME_DEPTH = 3
@@ -262,6 +260,8 @@ class GenerativeQFunc(BaseQFunc):
         return self._inferred_func_decl
 
     def __call__(self, *args: Any, **kwargs: Any) -> None:
+        if get_global_declarative_switch():
+            return QFunc(self._py_callable)(*args, **kwargs)
         if self.func_decl.name not in self._qmodule.generative_functions:
             self._qmodule.generative_functions[self.func_decl.name] = self
             if self._func_decl is None:
@@ -277,6 +277,13 @@ class GenerativeQFunc(BaseQFunc):
         preferences: Optional[Preferences] = None,
         classical_execution_function: Optional[CFunc] = None,
     ) -> Model:
+        if get_global_declarative_switch():
+            return QFunc(self._py_callable).create_model(
+                constraints,
+                execution_preferences,
+                preferences,
+                classical_execution_function,
+            )
         self._qmodule.reset()
         if self.func_decl.name == MAIN_FUNCTION_NAME:
             validate_main_function(self.func_decl)

classiq/qmod/utilities.py

@@ -20,6 +20,7 @@ from typing import (
     overload,
 )
 
+import sympy
 from typing_extensions import ParamSpec
 
 from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
@@ -101,6 +102,9 @@ def get_source_ref(frame: FrameType) -> SourceReference:
 
 
 def qmod_val_to_expr_str(val: Any) -> str:
+    if isinstance(val, sympy.Basic):
+        return str(val)
+
     if dataclasses.is_dataclass(type(val)):
         kwargs_str = ", ".join(
             [

classiq/qmod/write_qmod.py

@@ -1,9 +1,10 @@
 import json
 from pathlib import Path
-from typing import Any, Optional, Union
+from typing import Optional, Union
 
 from classiq.interface.model.model import Model, SerializedModel
 
+from classiq.qmod.global_declarative_switch import set_global_declarative_switch
 from classiq.qmod.native.pretty_printer import DSLPrettyPrinter
 from classiq.qmod.quantum_function import GenerativeQFunc, QFunc
 from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
@@ -17,8 +18,7 @@ def write_qmod(
     name: str,
     directory: Optional[Path] = None,
     decimal_precision: int = DEFAULT_DECIMAL_PRECISION,
-    *args: Any,
-    **kwargs: Any,
+    symbolic_only: bool = True,
 ) -> None:
     """
     Creates a native Qmod file from a serialized model and outputs the synthesis options (Preferences and Constraints) to a file.
@@ -29,20 +29,15 @@ def write_qmod(
         name: The name to save the file by.
         directory: The directory to save the files in. If None, the current working directory is used.
         decimal_precision: The number of decimal places to use for numbers, set to 4 by default.
-        args: (placeholder)
-        kwargs: (placeholder)
+        symbolic_only: If True keep function definitions un-expanded and symbolic (note that Qmod functions with parameters of Python types are not supported in this mode)
 
     Returns:
         None
     """
-    if isinstance(model, (QFunc, GenerativeQFunc)):
-        model_obj = model.create_model()
-    else:
-        model_obj = Model.model_validate_json(model)
+    model_obj = prepare_write_qmod_model(model, symbolic_only)
     pretty_printed_model = DSLPrettyPrinter(decimal_precision=decimal_precision).visit(
         model_obj
     )
-
     synthesis_options = model_obj.model_dump(
         include={"constraints", "preferences"}, exclude_none=True
     )
@@ -58,3 +53,34 @@ def write_qmod(
         native_qmod_path = directory / native_qmod_path
 
     native_qmod_path.write_text(pretty_printed_model)
+
+
+def prepare_write_qmod_model(
+    model: Union[SerializedModel, QFunc, GenerativeQFunc], symbolic_only: bool
+) -> Model:
+    if isinstance(model, str) and hasattr(model, "entry_point") and symbolic_only:
+        model_obj = Model.model_validate_json(model)
+        with set_global_declarative_switch():
+            dec_model_obj = model.entry_point.create_model(
+                constraints=model_obj.constraints,
+                execution_preferences=model_obj.execution_preferences,
+                preferences=model_obj.preferences,
+            )
+        dec_constant_names = {const.name for const in dec_model_obj.constants}
+        all_constants = dec_model_obj.constants + [
+            const
+            for const in model_obj.constants
+            if const.name not in dec_constant_names
+        ]
+        return dec_model_obj.model_copy(
+            update={
+                "constants": all_constants,
+                "classical_execution_code": model_obj.classical_execution_code,
+            }
+        )
+    if isinstance(model, (QFunc, GenerativeQFunc)):
+        if symbolic_only:
+            with set_global_declarative_switch():
+                return model.create_model()
+        return model.create_model()
+    return Model.model_validate_json(model)

classiq/synthesis.py

@@ -10,6 +10,7 @@ from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model, SerializedM
 from classiq import QuantumProgram
 from classiq._internals import async_utils
 from classiq._internals.api_wrapper import ApiWrapper
+from classiq.qmod.create_model_function import add_entry_point
 from classiq.qmod.quantum_function import BaseQFunc
 
 SerializedQuantumProgram = QuantumProgram
@@ -116,7 +117,7 @@ def set_preferences(
 
     model = Model.model_validate_json(serialized_model)
     model.preferences = preferences
-    return model.get_model()
+    return add_entry_point(model.get_model(), serialized_model)
 
 
 def update_preferences(
@@ -136,7 +137,7 @@ def update_preferences(
 
     for key, value in kwargs.items():
         setattr(model.preferences, key, value)
-    return model.get_model()
+    return add_entry_point(model.get_model(), serialized_model)
 
 
 def set_constraints(
@@ -164,7 +165,7 @@ def set_constraints(
 
     model = Model.model_validate_json(serialized_model)
     model.constraints = constraints
-    return model.get_model()
+    return add_entry_point(model.get_model(), serialized_model)
 
 
 def update_constraints(
@@ -184,7 +185,7 @@ def update_constraints(
 
     for key, value in kwargs.items():
         setattr(model.constraints, key, value)
-    return model.get_model()
+    return add_entry_point(model.get_model(), serialized_model)
 
 
 def set_execution_preferences(
@@ -213,7 +214,7 @@ def set_execution_preferences(
 
     model = Model.model_validate_json(serialized_model)
     model.execution_preferences = execution_preferences
-    return model.get_model()
+    return add_entry_point(model.get_model(), serialized_model)
 
 
 def update_execution_preferences(
@@ -234,7 +235,7 @@ def update_execution_preferences(
     for key, value in kwargs.items():
         setattr(model.execution_preferences, key, value)
 
-    return model.get_model()
+    return add_entry_point(model.get_model(), serialized_model)
 
 
 __all__ = [

{classiq-0.76.0.dist-info → classiq-0.78.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: classiq
-Version: 0.76.0
+Version: 0.78.0
 Summary: Classiq's Python SDK for quantum computing
 License: Proprietary
 Keywords: quantum computing,quantum circuits,quantum algorithms,QAD,QDL