classiq 0.61.0__py3-none-any.whl → 0.63.0__py3-none-any.whl

classiq/qmod/pretty_print/pretty_printer.py

@@ -412,7 +412,7 @@ class PythonPrettyPrinter(Visitor):
     def visit_PhaseOperation(self, op: PhaseOperation) -> str:
         self._imports["phase"] = 1
         theta = f", {self.visit(op.theta)}" if op.theta is not None else ""
-        return f"{self._indent}phase({self.visit(op.expression)},{theta})\n"
+        return f"{self._indent}phase({self.visit(op.expression)}{theta})\n"
 
     def visit_ClassicalIf(self, op: ClassicalIf) -> str:
         self._imports["if_"] = 1

classiq/qmod/python_classical_type.py

@@ -1,6 +1,5 @@
 import dataclasses
 import inspect
-import sys
 from enum import EnumMeta
 from typing import (
     Optional,
@@ -16,16 +15,13 @@ from classiq.interface.generator.functions.classical_type import (
     Integer,
     Real,
 )
+from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 from classiq.interface.generator.functions.type_name import Enum, Struct
 
 from classiq.qmod.cparam import CArray, CBool, CInt, CReal
 from classiq.qmod.qmod_variable import get_type_hint_expr
 from classiq.qmod.utilities import version_portable_get_args
 
-if sys.version_info[0:2] >= (3, 9):
-    pass
-from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
-
 CARRAY_ERROR_MESSAGE = (
     "CArray accepts one or two generic parameters in the form "
     "`CArray[<element-type>]` or `CArray[<element-type>, <size>]`"

classiq/qmod/qfunc.py

@@ -1,3 +1,5 @@
+from collections.abc import Iterator
+from contextlib import contextmanager
 from typing import Callable, Literal, Optional, Union, overload
 
 from classiq.interface.exceptions import ClassiqInternalError
@@ -10,17 +12,16 @@ from classiq.qmod.quantum_function import (
     QFunc,
 )
 
-GEN_QFUNCS: list[GenerativeQFunc] = []
-DEC_QFUNCS: list[QFunc] = []
+_GENERATIVE_SWITCH = False
 
 
-def set_discovered_functions(
-    dec_funcs: list[QFunc], gen_funcs: list[GenerativeQFunc]
-) -> None:
-    DEC_QFUNCS.clear()
-    DEC_QFUNCS.extend(dec_funcs)
-    GEN_QFUNCS.clear()
-    GEN_QFUNCS.extend(gen_funcs)
+@contextmanager
+def set_global_generative_switch() -> Iterator[None]:
+    global _GENERATIVE_SWITCH
+    previous = _GENERATIVE_SWITCH
+    _GENERATIVE_SWITCH = True
+    yield
+    _GENERATIVE_SWITCH = previous
 
 
 @overload
@@ -56,9 +57,8 @@ def qfunc(
 ) -> Union[Callable[[Callable], QCallable], QCallable]:
     def wrapper(func: Callable) -> QCallable:
         qfunc: BaseQFunc
-        if generative:
+        if generative or _GENERATIVE_SWITCH:
             qfunc = GenerativeQFunc(func)
-            GEN_QFUNCS.append(qfunc)
         elif external:
             if synthesize_separately:
                 raise ClassiqInternalError(
@@ -67,7 +67,6 @@ def qfunc(
             return ExternalQFunc(func)
         else:
             qfunc = QFunc(func)
-            DEC_QFUNCS.append(qfunc)
         if synthesize_separately:
             qfunc.update_compilation_metadata(should_synthesize_separately=True)
         return qfunc

classiq/qmod/qmod_variable.py

@@ -285,7 +285,7 @@ class QNum(Generic[_P], QScalar):
     def __init__(
         self,
         name: Union[str, HandleBinding],
-        size: Union[int, CInt, Expression, None] = None,
+        size: Union[int, CInt, Expression, SymbolicExpr, None] = None,
         is_signed: Union[bool, Expression, SymbolicExpr, None] = None,
         fraction_digits: Union[int, CInt, Expression, None] = None,
         _expr_str: Optional[str] = None,
@@ -485,8 +485,6 @@ class QArray(ArrayBase[_P], QVar):
             if is_generative_mode():
                 with generative_mode_context(False):
                     return interpret_expression(str(self.len))
-            if self._length is not None:
-                return CParamScalar(f"{self._length}")
             return CParamScalar(f"get_field({self}, 'len')")
 
     @classmethod

classiq/qmod/quantum_expandable.py

@@ -101,6 +101,10 @@ 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:
         if self not in QExpandable.STACK:
             with self, generative_mode_context(False):
@@ -161,6 +165,17 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
             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__(
@@ -298,6 +313,12 @@ 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
+
+    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))
@@ -336,7 +357,8 @@ def prepare_arg(
                 pos_rename_params=val.infer_rename_params(),
                 body=val.body,
             )
-            qlambda.set_py_callable(val._py_callable)
+            if is_generative_mode():
+                qlambda.set_py_callable(val._py_callable)
             return qlambda
 
         if isinstance(val, QExpandable):

classiq/qmod/quantum_function.py

@@ -1,5 +1,7 @@
 import ast
 import functools
+from abc import abstractmethod
+from collections import defaultdict
 from dataclasses import is_dataclass
 from enum import EnumMeta
 from inspect import isclass
@@ -23,6 +25,7 @@ from classiq.interface.model.quantum_function_declaration import (
 
 from classiq.qmod.classical_function import CFunc
 from classiq.qmod.declaration_inferrer import infer_func_decl
+from classiq.qmod.generative import set_frontend_interpreter
 from classiq.qmod.qmod_constant import QConstant
 from classiq.qmod.qmod_parameter import CArray, CParam
 from classiq.qmod.qmod_variable import QVar
@@ -62,9 +65,19 @@ class BaseQFunc(QExpandable):
             return CompilationMetadata()
         return self.compilation_metadata
 
+    @abstractmethod
+    def create_model(
+        self,
+        constraints: Optional[Constraints] = None,
+        execution_preferences: Optional[ExecutionPreferences] = None,
+        preferences: Optional[Preferences] = None,
+        classical_execution_function: Optional[CFunc] = None,
+    ) -> Model:
+        pass
+
 
 class QFunc(BaseQFunc):
-    FRAME_DEPTH = 2
+    FRAME_DEPTH = 3
 
     def __init__(
         self,
@@ -90,14 +103,14 @@ class QFunc(BaseQFunc):
 
     @property
     def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
-        return self._qmodule.native_defs.get(
-            self._py_callable.__name__,
-            infer_func_decl(self._py_callable, qmodule=self._qmodule),
-        )
+        name = self._py_callable.__name__
+        if hasattr(self._qmodule, "native_defs") and name in self._qmodule.native_defs:
+            return self._qmodule.native_defs[name]
+        return infer_func_decl(self._py_callable, qmodule=self._qmodule)
 
     def __call__(self, *args: Any, **kwargs: Any) -> None:
-        super().__call__(*args, **kwargs)
         self.expand()
+        super().__call__(*args, **kwargs)
 
     def create_model(
         self,
@@ -112,6 +125,8 @@ class QFunc(BaseQFunc):
         self._qmodule.native_defs = dict()
         self._qmodule.constants = dict()
         self._qmodule.functions_compilation_metadata = dict()
+        self._qmodule.generative_functions = dict()
+        self._qmodule.function_dependencies = defaultdict(list)
         QConstant.set_current_model(self._qmodule)
         self.expand()
         model_extra_settings: list[tuple[str, Any]] = [
@@ -124,7 +139,7 @@ class QFunc(BaseQFunc):
             model_extra_settings.append(
                 ("classical_execution_code", classical_execution_function.code)
             )
-        return Model(
+        model = Model(
             constants=list(self._qmodule.constants.values()),
             functions=list(self._qmodule.native_defs.values()),
             enums=list(self._qmodule.enum_decls.values()),
@@ -133,6 +148,30 @@ 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:
+            return self._create_generative_model(model)
+        return model
+
+    def _create_generative_model(self, model_stub: Model) -> Model:
+        from classiq.model_expansions.interpreter import Interpreter
+        from classiq.qmod.semantics.static_semantics_visitor import (
+            resolve_function_calls,
+        )
+
+        generative_functions = list(self._qmodule.generative_functions.values())
+        resolve_function_calls(
+            model_stub,
+            dict(model_stub.function_dict)
+            | {
+                gen_func.func_decl.name: gen_func.func_decl
+                for gen_func in generative_functions
+            },
+        )
+        interpreter = Interpreter(
+            model_stub, generative_functions, is_normalizer=True, is_shallow=True
+        )
+        set_frontend_interpreter(interpreter)
+        return interpreter.expand()
 
     def expand(self) -> None:
         if self.func_decl.name in self._qmodule.native_defs:
@@ -220,6 +259,29 @@ class GenerativeQFunc(BaseQFunc):
             self._func_decl = infer_func_decl(self._py_callable, self._qmodule)
         return self._func_decl
 
+    def __call__(self, *args: Any, **kwargs: Any) -> None:
+        self._qmodule.generative_functions[self.func_decl.name] = self
+        super().__call__(*args, **kwargs)
+
+    def create_model(
+        self,
+        constraints: Optional[Constraints] = None,
+        execution_preferences: Optional[ExecutionPreferences] = None,
+        preferences: Optional[Preferences] = None,
+        classical_execution_function: Optional[CFunc] = None,
+    ) -> Model:
+        def _dec_main(*args: Any, **kwargs: Any) -> None:
+            self(*args, **kwargs)
+
+        _dec_main.__annotations__ = self._py_callable.__annotations__
+
+        return QFunc(_dec_main).create_model(
+            constraints=constraints,
+            execution_preferences=execution_preferences,
+            preferences=preferences,
+            classical_execution_function=classical_execution_function,
+        )
+
 
 ILLEGAL_PARAM_ERROR = "Unsupported type hint '{annotation}' for argument '{name}'."
 

{classiq-0.61.0.dist-info → classiq-0.63.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: classiq
-Version: 0.61.0
+Version: 0.63.0
 Summary: Classiq's Python SDK for quantum computing
 Home-page: https://classiq.io
 License: Proprietary
@@ -53,6 +53,7 @@ Requires-Dist: sympy (>=1.13.0,<2.0.0)
 Requires-Dist: tabulate (>=0.8.9,<1)
 Requires-Dist: torch (>=2.0,<3.0) ; extra == "qml"
 Requires-Dist: torchvision (>=0.15,<1.0) ; extra == "qml"
+Requires-Dist: tqdm (>=4.67.1,<5.0.0)
 Project-URL: Documentation, https://docs.classiq.io/
 Description-Content-Type: text/markdown