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

classiq/qmod/builtins/functions/allocation.py

@@ -0,0 +1,150 @@
+from typing import Literal
+
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_parameter import CArray, CInt, CReal
+from classiq.qmod.qmod_variable import Input, Output, QArray, QBit
+
+
+@qfunc(external=True)
+def allocate(
+    num_qubits: CInt, out: Output[QArray[QBit, Literal["num_qubits"]]]
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Allocates the specified number of qubits to a given quantum variable and initializes
+    them in the zero state:
+
+    $$
+        \\left|\\text{out}\\right\\rangle = \\left|0\\right\\rangle^{\\otimes \\text{num_qubits}}
+    $$
+
+    Args:
+        num_qubits: The number of qubits to allocate. Must be a positive integer.
+        out: The quantum variable that will receive the allocated qubits. Must be uninitialized before allocation.
+
+    Notes:
+        1. If the output variable has been declared with a specific number of qubits, the number of qubits allocated must match the declared number.
+        2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
+    """
+    pass
+
+
+@qfunc(external=True)
+def free(in_: Input[QArray[QBit]]) -> None:
+    """
+    [Qmod core-library function]
+
+    Releases the qubits allocated to a quantum variable, allowing them to be reused.
+
+    Args:
+        in_: The quantum variable that will be freed. Must be initialized before.
+
+    Note:
+        This operation does not uncompute the qubits. It is the responsibility of the user to ensure that the qubits are at the zero state before freeing them.
+    """
+    pass
+
+
+@qfunc(external=True)
+def prepare_state(
+    probabilities: CArray[CReal],
+    bound: CReal,
+    out: Output[QArray[QBit, Literal["log(get_field(probabilities, 'len'), 2)"]]],
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Initializes a quantum variable in a state corresponding to a given probability distribution:
+
+    $$
+        \\left|\\text{out}\\right\\rangle = \\sum_{i=0}^{\\text{len(probabilities)}-1} \\sqrt{\\text{probabilities}[i]} \\left|i\\right\\rangle
+    $$
+
+    with $i = 0, 1, 2, ..., \\text{len(amplitudes)}-1$ corresponding to computational basis states.
+
+    Args:
+        probabilities: The probability distribution to initialize the quantum variable. Must be a valid probability distribution, i.e., a list of non-negative real numbers that sum to 1. Must have a valid length (a power of 2).
+        bound: An error bound, expressed as the $L^{2}$ norm between the expected and actual distributions. A larger bound can reduce the circuit size at the expense of accuracy. Must be a positive real number.
+        out: The quantum variable that will receive the initialized state. Must be uninitialized.
+
+    Notes:
+        1. If the output variable has been declared with a specific number of qubits, the number of qubits formed by the distribution must match the declared number.
+        2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
+    """
+    pass
+
+
+@qfunc(external=True)
+def prepare_amplitudes(
+    amplitudes: CArray[CReal],
+    bound: CReal,
+    out: Output[QArray[QBit, Literal["log(get_field(amplitudes, 'len'), 2)"]]],
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Initializes a quantum variable in a state corresponding to the given amplitudes:
+
+    $$
+        \\left|\\text{out}\\right\\rangle = \\sum_{i=0}^{\\text{len(amplitudes)}-1} \\text{amplitudes}[i] \\left|i\\right\\rangle
+    $$
+
+    with $i = 0, 1, 2, ..., \\text{len(amplitudes)}-1$ corresponding to computational basis states.
+
+    Args:
+        amplitudes: The amplitudes to initialize the quantum variable. Must be a valid real quantum state vector, i.e., the sum of squares should be 1. Must have a valid length (a power of 2).
+        bound: An error bound, expressed as the $L^{2}$ norm between the expected and actual distributions. A larger bound can reduce the circuit size at the expense of accuracy. Must be a positive real number.
+        out: The quantum variable that will receive the initialized state. Must be uninitialized.
+
+    Notes:
+        1. If the output variable has been declared with a specific number of qubits, the number of qubits formed by the distribution must match the declared number.
+        2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
+    """
+    pass
+
+
+@qfunc(external=True)
+def inplace_prepare_state(
+    probabilities: CArray[CReal],
+    bound: CReal,
+    target: QArray[QBit, Literal["log(get_field(probabilities, 'len'), 2)"]],
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Transforms a given quantum variable in the state |0> to the state per the specified probability distribution
+    (similar to `prepare_state` but preformed on an initialized variable).
+
+    Args:
+        probabilities: The probability distribution corresponding to the quantum variable state. Must be a valid probability distribution, i.e., a list of non-negative real numbers that sum to 1. Must have a valid length (a power of 2).
+        bound: An error bound, expressed as the $L^{2}$ norm between the expected and actual distributions. A larger bound can reduce the circuit size at the expense of accuracy. Must be a positive real number.
+        target: The quantum variable to act upon.
+
+    This is useful as part of quantum building blocks like the Grover diffuser operator, $\\left|\\psi\\right\\rangle\\left\\langle\\psi\\right| \\left( 2\\left|0\\right\\rangle\\left\\langle0\\right| - \\mathcal{I} \\right)$, where the output state of the oracle is reflected about this state.
+
+    """
+    pass
+
+
+@qfunc(external=True)
+def inplace_prepare_amplitudes(
+    amplitudes: CArray[CReal],
+    bound: CReal,
+    target: QArray[QBit, Literal["log(get_field(amplitudes, 'len'), 2)"]],
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Transforms a given quantum variable in the state |0> to the state per the specified amplitudes
+    (similar to `prepare_amplitudes` but preformed on an initialized variable).
+
+    Args:
+        amplitudes: The amplitudes to initialize the quantum variable. Must be a valid real quantum state vector, i.e., the sum of squares should be 1. Must have a valid length (a power of 2).
+        bound: An error bound, expressed as the $L^{2}$ norm between the expected and actual distributions. A larger bound can reduce the circuit size at the expense of accuracy. Must be a positive real number.
+        target: The quantum variable to act upon.
+
+    This is useful as part of quantum building blocks like the Grover diffuser operator, $\\left|\\psi\\right\\rangle\\left\\langle\\psi\\right| \\left( 2\\left|0\\right\\rangle\\left\\langle0\\right| - \\mathcal{I} \\right)$, where the output state of the oracle is reflected about this state.
+
+    """
+    pass

classiq/qmod/builtins/functions/arithmetic.py

@@ -1,13 +1,8 @@
 from typing import Literal
 
-from classiq.qmod.builtins.functions.qft_functions import qft
-from classiq.qmod.builtins.functions.standard_gates import PHASE
-from classiq.qmod.builtins.operations import bind, repeat, within_apply
-from classiq.qmod.cparam import CInt
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray, CReal
 from classiq.qmod.qmod_variable import Output, QArray, QBit, QNum
-from classiq.qmod.symbolic import pi
 
 
 @qfunc(external=True)
@@ -58,32 +53,3 @@ def integer_xor(left: QArray[QBit], right: QArray[QBit]) -> None:
 @qfunc(external=True)
 def real_xor_constant(left: CReal, right: QNum) -> None:
     pass
-
-
-@qfunc
-def modular_increment(a: CInt, x: QNum) -> None:
-    """
-    [Qmod Classiq-library function]
-
-    Adds $a$ to $x$ modulo the range of $x$, assumed that $x$ is a non-negative integer and $a$ is an integer.
-    Mathematically it is described as:
-
-    $$
-        x = (x+a)\\ \\mod \\ 2^{x.size}-1
-    $$
-
-    Args:
-        a: A classical integer to be added to x.
-        x: A quantum number that is assumed to be non-negative integer.
-
-    """
-    array_cast: QArray = QArray("array_cast")
-    within_apply(
-        lambda: (  # type:ignore[arg-type]
-            bind(x, array_cast),  # type:ignore[func-returns-value]
-            qft(array_cast),
-        ),
-        lambda: repeat(
-            x.size, lambda i: PHASE(a * 2 * pi * 2**i / (2**x.size), array_cast[i])
-        ),
-    )

classiq/qmod/builtins/functions/operators.py

@@ -1,4 +1,3 @@
-from classiq.qmod.cparam import CInt
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.quantum_callable import QCallable, QCallableList
 
@@ -15,8 +14,3 @@ def apply(
     operand: QCallable,
 ) -> None:
     pass
-
-
-@qfunc
-def switch(selector: CInt, cases: QCallableList) -> None:
-    cases[selector]()

classiq/qmod/builtins/operations.py

@@ -1,16 +1,12 @@
 import inspect
 import sys
-import warnings
 from collections.abc import Mapping
 from types import FrameType
 from typing import (
-    TYPE_CHECKING,
     Any,
     Callable,
     Final,
-    Optional,
     Union,
-    overload,
 )
 
 from classiq.interface.exceptions import ClassiqValueError
@@ -44,7 +40,8 @@ from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.within_apply_operation import WithinApply
 
-from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QNum, QScalar, QVar
+from classiq.qmod.generative import is_generative_mode
+from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QScalar, QVar
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_expandable import prepare_arg
 from classiq.qmod.symbolic_expr import SymbolicExpr
@@ -89,9 +86,10 @@ def if_(
         else_=_operand_to_body(else_, "else") if else_ != _MISSING_VALUE else [],  # type: ignore[arg-type]
         source_ref=source_ref,
     )
-    if_stmt.set_generative_block("then", then)
-    if callable(else_):
-        if_stmt.set_generative_block("else", else_)
+    if is_generative_mode():
+        if_stmt.set_generative_block("then", then)
+        if callable(else_):
+            if_stmt.set_generative_block("else", else_)
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(if_stmt)
 
 
@@ -109,9 +107,10 @@ def control(
         else_block=_operand_to_body(else_block, "else_block") if else_block else None,
         source_ref=source_ref,
     )
-    control_stmt.set_generative_block("body", stmt_block)
-    if else_block is not None:
-        control_stmt.set_generative_block("else_block", else_block)
+    if is_generative_mode():
+        control_stmt.set_generative_block("body", stmt_block)
+        if else_block is not None:
+            control_stmt.set_generative_block("else_block", else_block)
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(control_stmt)
 
 
@@ -161,22 +160,7 @@ def assign_amplitude(expression: SymbolicExpr, target_var: QScalar) -> None:
     )
 
 
-@overload
 def inplace_add(expression: SymbolicExpr, target_var: QScalar) -> None:
-    pass
-
-
-@overload
-def inplace_add(*, value: QNum, target: QNum) -> None:
-    pass
-
-
-def inplace_add(
-    expression: Optional[SymbolicExpr] = None,
-    target_var: Optional[QScalar] = None,
-    value: Optional[QNum] = None,
-    target: Optional[QNum] = None,
-) -> None:
     """
     Add an arithmetic expression to a quantum variable.
 
@@ -187,23 +171,6 @@ def inplace_add(
         target_var: A scalar quantum variable
     """
     assert QCallable.CURRENT_EXPANDABLE is not None
-    if value is not None or target is not None:
-        warnings.warn(
-            "Parameters 'value' and 'target of function 'inplace_add' have "
-            "been renamed to 'expression' and 'target_var' respectively. Parameters "
-            "'value' and 'target' will no longer be supported starting on 02/12/24 at "
-            "the earliest.\nHint: Change `inplace_add(value=..., target=...)` to "
-            "`inplace_add(expression=..., target_var=...)` or `inplace_add(..., ...)`.",
-            category=DeprecationWarning,
-            stacklevel=2,
-        )
-    if value is not None:
-        expression = value
-    if target is not None:
-        target_var = target
-    if TYPE_CHECKING:
-        assert expression is not None
-        assert target_var is not None
     source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         ArithmeticOperation(
@@ -215,22 +182,7 @@ def inplace_add(
     )
 
 
-@overload
 def inplace_xor(expression: SymbolicExpr, target_var: QScalar) -> None:
-    pass
-
-
-@overload
-def inplace_xor(*, value: QNum, target: QNum) -> None:
-    pass
-
-
-def inplace_xor(
-    expression: Optional[SymbolicExpr] = None,
-    target_var: Optional[QScalar] = None,
-    value: Optional[QNum] = None,
-    target: Optional[QNum] = None,
-) -> None:
     """
     Bitwise-XOR a quantum variable with an arithmetic expression.
 
@@ -241,23 +193,6 @@ def inplace_xor(
         target_var: A scalar quantum variable
     """
     assert QCallable.CURRENT_EXPANDABLE is not None
-    if value is not None or target is not None:
-        warnings.warn(
-            "Parameters 'value' and 'target of function 'inplace_xor' have "
-            "been renamed to 'expression' and 'target_var' respectively. Parameters "
-            "'value' and 'target' will no longer be supported starting on 02/12/24 at "
-            "the earliest.\nHint: Change `inplace_xor(value=..., target=...)` to "
-            "`inplace_xor(expression=..., target_var=...)` or `inplace_xor(..., ...)`.",
-            category=DeprecationWarning,
-            stacklevel=2,
-        )
-    if value is not None:
-        expression = value
-    if target is not None:
-        target_var = target
-    if TYPE_CHECKING:
-        assert expression is not None
-        assert target_var is not None
     source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         ArithmeticOperation(
@@ -282,8 +217,9 @@ def within_apply(
         action=_operand_to_body(apply, "apply"),
         source_ref=source_ref,
     )
-    within_apply_stmt.set_generative_block("within", within)
-    within_apply_stmt.set_generative_block("apply", apply)
+    if is_generative_mode():
+        within_apply_stmt.set_generative_block("within", within)
+        within_apply_stmt.set_generative_block("apply", apply)
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(within_apply_stmt)
 
 
@@ -313,7 +249,8 @@ def repeat(count: Union[SymbolicExpr, int], iteration: Callable[[int], None]) ->
         body=iteration_operand.body,
         source_ref=source_ref,
     )
-    repeat_stmt.set_generative_block("body", iteration)
+    if is_generative_mode():
+        repeat_stmt.set_generative_block("body", iteration)
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(repeat_stmt)
 
 
@@ -329,7 +266,8 @@ def power(
         body=_operand_to_body(stmt_block, "stmt_block"),
         source_ref=source_ref,
     )
-    power_stmt.set_generative_block("body", stmt_block)
+    if is_generative_mode():
+        power_stmt.set_generative_block("body", stmt_block)
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(power_stmt)
 
 
@@ -340,7 +278,8 @@ def invert(stmt_block: Union[QCallable, Callable[[], None]]) -> None:
     invert_stmt = Invert(
         body=_operand_to_body(stmt_block, "stmt_block"), source_ref=source_ref
     )
-    invert_stmt.set_generative_block("body", stmt_block)
+    if is_generative_mode():
+        invert_stmt.set_generative_block("body", stmt_block)
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(invert_stmt)
 
 

classiq/qmod/create_model_function.py

@@ -1,30 +1,15 @@
-from typing import TYPE_CHECKING, Optional, Union, cast
+from typing import Optional, Union
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.model.constraints import Constraints
 from classiq.interface.generator.model.preferences.preferences import Preferences
-from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
-from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model, SerializedModel
-from classiq.interface.model.native_function_definition import NativeFunctionDefinition
-from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.model import MAIN_FUNCTION_NAME, SerializedModel
 
-from classiq.model_expansions.interpreter import Interpreter
-from classiq.qmod.builtins.functions import BUILTIN_FUNCTION_DECLARATIONS
 from classiq.qmod.classical_function import CFunc
-from classiq.qmod.generative import (
-    is_generative_expansion_enabled,
-    set_frontend_interpreter,
-)
-from classiq.qmod.model_state_container import QMODULE
-from classiq.qmod.qfunc import DEC_QFUNCS, GEN_QFUNCS
-from classiq.qmod.quantum_expandable import _prepare_args
 from classiq.qmod.quantum_function import GenerativeQFunc, QFunc
-from classiq.qmod.semantics.static_semantics_visitor import resolve_function_calls
 from classiq.qmod.write_qmod import write_qmod
 
-GEN_MAIN_NAME = "_gen_main"
-
 
 def create_model(
     entry_point: Union[QFunc, GenerativeQFunc],
@@ -57,154 +42,15 @@ def create_model(
             f"The entry point function must be named 'main', got '{entry_point.func_decl.name}'"
         )
 
-    user_gen_functions = {
-        gen_func._py_callable.__name__ for gen_func in GEN_QFUNCS
-    } - set(BUILTIN_FUNCTION_DECLARATIONS.keys())
-
-    if len(user_gen_functions) > 0 and is_generative_expansion_enabled():
-        model = _expand_generative_model(
-            (
-                entry_point
-                if isinstance(entry_point, QFunc)
-                else QFunc(entry_point._py_callable)
-            ),
-            constraints,
-            execution_preferences,
-            preferences,
-        )
-    else:
-        if TYPE_CHECKING:
-            assert isinstance(entry_point, QFunc)
-        model = entry_point.create_model(
-            constraints,
-            execution_preferences,
-            preferences,
-            classical_execution_function,
-        )
-    result = model.get_model()
-
-    if out_file is not None:
-        write_qmod(result, out_file)
-
-    return result
-
-
-def _expand_generative_model(
-    gen_main: QFunc,
-    constraints: Optional[Constraints] = None,
-    execution_preferences: Optional[ExecutionPreferences] = None,
-    preferences: Optional[Preferences] = None,
-) -> Model:
-    @QFunc
-    def _dummy() -> None:
-        pass
-
-    model = _dummy.create_model(
+    model = entry_point.create_model(
         constraints,
         execution_preferences,
         preferences,
+        classical_execution_function,
     )
-    gen_expand_model = _get_generative_functions(gen_main, preferences)
-    model.functions = gen_expand_model.functions
-    model.functions_compilation_metadata = (
-        gen_expand_model.functions_compilation_metadata
-    )
-    model.types = list(QMODULE.type_decls.values())
-    model.enums = list(QMODULE.enum_decls.values())
-    model.qstructs = list(QMODULE.qstruct_decls.values())
-    return model
-
-
-def _get_generative_functions(
-    gen_main: QFunc,
-    preferences: Optional[Preferences],
-) -> Model:
-    # The Interpreter accepts a model and a list of generative functions.
-    # Since the main function is generative, it can only be expanded using the
-    # Interpreter.
-    # To solve this deadlock, we create a wrapper model
-    # `qfunc main(...) { _gen_main(...); }` and rename `main` to `_gen_main` before
-    # passing them to the Interpreter.
-    gen_model = _get_wrapper_main(gen_main, preferences)
-    gen_functions = _get_all_model_functions_as_generative_functions()
-    return _interpret_generative_model(gen_model, gen_functions)
-
-
-def _get_wrapper_main(
-    gen_main: QFunc,
-    preferences: Optional[Preferences],
-) -> Model:
-    extra_args = {}
-    if preferences is not None:
-        extra_args["preferences"] = preferences
-    functions_compilation_metadata = {
-        qfunc._py_callable.__name__: qfunc.compilation_metadata
-        for qfunc in DEC_QFUNCS + GEN_QFUNCS
-        if qfunc.compilation_metadata is not None
-    }
-    return Model(
-        functions=[
-            NativeFunctionDefinition(
-                name=MAIN_FUNCTION_NAME,
-                positional_arg_declarations=gen_main.func_decl.positional_arg_declarations,
-                body=[
-                    QuantumFunctionCall(
-                        function=GEN_MAIN_NAME,
-                        positional_args=_prepare_args(
-                            gen_main.func_decl,
-                            gen_main._get_positional_args(),
-                            {},
-                        ),
-                    ),
-                ],
-            ),
-        ],
-        functions_compilation_metadata=functions_compilation_metadata,
-        **extra_args,
-    )
-
-
-def _get_all_model_functions_as_generative_functions() -> list[GenerativeQFunc]:
-
-    gen_functions = list(GEN_QFUNCS) + [
-        GenerativeQFunc(
-            dec_func._py_callable, dec_func.func_decl, dec_func.compilation_metadata
-        )
-        for dec_func in DEC_QFUNCS
-    ]
-    return [
-        (
-            gen_func
-            if gen_func.func_decl.name != MAIN_FUNCTION_NAME
-            else GenerativeQFunc(
-                gen_func._py_callable,
-                gen_func.func_decl.model_copy(update={"name": GEN_MAIN_NAME}),
-                gen_func.compilation_metadata,
-            )
-        )
-        for gen_func in gen_functions
-        if gen_func.func_decl.name not in BUILTIN_FUNCTION_DECLARATIONS
-    ]
-
+    result = model.get_model()
 
-def _interpret_generative_model(
-    gen_model: Model, gen_functions: list[GenerativeQFunc]
-) -> Model:
-    resolve_function_calls(
-        gen_model,
-        {gen_func.func_decl.name: gen_func.func_decl for gen_func in gen_functions},
-    )
-    interpreter = Interpreter(gen_model, gen_functions, is_frontend=True)
-    set_frontend_interpreter(interpreter)
-    expand_model = interpreter.expand()
-    functions_dict = nameables_to_dict(expand_model.functions)
+    if out_file is not None:
+        write_qmod(result, out_file)
 
-    # Inline _gen_main call in main
-    expanded_gen_main_name = cast(
-        QuantumFunctionCall, functions_dict[MAIN_FUNCTION_NAME].body[0]
-    ).func_name
-    functions_dict[MAIN_FUNCTION_NAME] = functions_dict[
-        expanded_gen_main_name
-    ].model_copy(update={"name": MAIN_FUNCTION_NAME})
-    functions_dict.pop(expanded_gen_main_name)
-    return expand_model.model_copy(update={"functions": list(functions_dict.values())})
+    return result

classiq/qmod/generative.py

@@ -8,7 +8,6 @@ from classiq.interface.generator.expressions.expression import Expression
 if TYPE_CHECKING:
     from classiq.model_expansions.interpreter import Interpreter
 
-_GENERATIVE_ENABLED_SWITCH: bool = True
 _GENERATIVE_MODE: bool = False
 _FRONTEND_INTERPRETER: Optional["Interpreter"] = None
 
@@ -28,21 +27,6 @@ def generative_mode_context(generative: bool) -> Iterator[None]:
         _GENERATIVE_MODE = previous
 
 
-@contextmanager
-def enable_generative_expansion(enabled: bool) -> Iterator[None]:
-    global _GENERATIVE_ENABLED_SWITCH
-    previous = _GENERATIVE_ENABLED_SWITCH
-    _GENERATIVE_ENABLED_SWITCH = enabled
-    try:
-        yield
-    finally:
-        _GENERATIVE_ENABLED_SWITCH = previous
-
-
-def is_generative_expansion_enabled() -> bool:
-    return _GENERATIVE_ENABLED_SWITCH
-
-
 def set_frontend_interpreter(interpreter: "Interpreter") -> None:
     global _FRONTEND_INTERPRETER
     _FRONTEND_INTERPRETER = interpreter

classiq/qmod/model_state_container.py

@@ -1,3 +1,5 @@
+from typing import TYPE_CHECKING
+
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
@@ -7,6 +9,9 @@ from classiq.interface.model.native_function_definition import (
     NativeFunctionDefinition,
 )
 
+if TYPE_CHECKING:
+    from classiq.qmod.quantum_function import GenerativeQFunc
+
 
 class ModelStateContainer:
     enum_decls: dict[str, EnumDeclaration]
@@ -15,6 +20,8 @@ class ModelStateContainer:
     native_defs: dict[str, NativeFunctionDefinition]
     constants: dict[str, Constant]
     functions_compilation_metadata: dict[str, CompilationMetadata]
+    generative_functions: dict[str, "GenerativeQFunc"]
+    function_dependencies: dict[str, list[str]]
 
 
 QMODULE = ModelStateContainer()

classiq/qmod/native/pretty_printer.py

@@ -78,7 +78,7 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
-from classiq.qmod.builtins.functions import OPEN_LIBRARY_FUNCTIONS
+from classiq.open_library.functions import OPEN_LIBRARY_FUNCTIONS
 from classiq.qmod.native.expression_to_qmod import transform_expression
 from classiq.qmod.semantics.static_semantics_visitor import resolve_function_calls
 from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
@@ -114,16 +114,15 @@ class DSLPrettyPrinter(Visitor):
             else []
         )
 
-        return "\n".join(
-            [
-                *constants,
-                *enum_decls,
-                *struct_decls,
-                *qstruct_decls,
-                *func_defs,
-                *classical_code,
-            ]
-        )
+        items = [
+            *constants,
+            *enum_decls,
+            *struct_decls,
+            *qstruct_decls,
+            *func_defs,
+            *classical_code,
+        ]
+        return "\n".join([item for item in items if item != ""])
 
     def visit_Constant(self, constant: Constant) -> str:
         return f"{self._indent}{self.visit(constant.name)}: {self.visit(constant.const_type)} = {self.visit(constant.value)};\n"