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

classiq/model_expansions/expression_renamer.py

@@ -0,0 +1,76 @@
+import ast
+from collections.abc import Sequence
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.expression_constants import (
+    RESERVED_EXPRESSIONS,
+)
+from classiq.interface.generator.visitor import Transformer
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_function_declaration import (
+    ClassicalParameterDeclaration,
+    PositionalArg,
+)
+
+from classiq.model_expansions.visitors.variable_references import VarRefTransformer
+
+
+class ExpressionRenamer(Transformer):
+
+    def __init__(self, var_mapping: dict[str, str]) -> None:
+        self.var_ref_transformer = VarRefTransformer(var_mapping)
+
+    @property
+    def var_mapping(self) -> dict[str, str]:
+        return self.var_ref_transformer.var_mapping
+
+    def visit_QuantumFunctionCall(
+        self, node: QuantumFunctionCall
+    ) -> QuantumFunctionCall:
+        update_dict = dict(
+            positional_args=[self.visit(arg) for arg in node.positional_args],
+        )
+        return node.model_copy(update=update_dict)
+
+    def visit_Expression(self, expression: Expression) -> Expression:
+        parsed_expr = ast.parse(expression.expr)
+        renamed_expr = self.var_ref_transformer.visit(parsed_expr)
+        return Expression(expr=ast.unparse(renamed_expr))
+
+    def rename_string(self, name: str) -> str:
+        return self.var_mapping.get(name, name)
+
+    def rename_expression_dict(
+        self, expr_dict: dict[str, Expression]
+    ) -> dict[str, Expression]:
+        return {
+            self.rename_string(key): self.visit(val) for key, val in expr_dict.items()
+        }
+
+    @classmethod
+    def from_positional_arg_declarations(
+        cls, positional_arg_declarations: Sequence[PositionalArg], suffix: str
+    ) -> "ExpressionRenamer":
+        var_mapping: dict[str, str] = dict()
+        for arg in positional_arg_declarations:
+            if not isinstance(arg, ClassicalParameterDeclaration):
+                continue
+            if arg.name in RESERVED_EXPRESSIONS:
+                continue
+            new_name = arg.name + suffix
+            var_mapping[arg.name] = new_name
+
+        return cls(var_mapping)
+
+    def rename_positional_arg_declarations(
+        self, positional_arg_declarations: Sequence[PositionalArg]
+    ) -> Sequence[PositionalArg]:
+        return tuple(
+            (
+                arg.rename(self.var_mapping[arg.name])
+                if isinstance(arg, ClassicalParameterDeclaration)
+                and arg.name in self.var_mapping
+                else arg
+            )
+            for arg in positional_arg_declarations
+        )

classiq/model_expansions/function_builder.py

@@ -0,0 +1,247 @@
+from collections.abc import Iterator, Sequence
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from typing import Generic, Optional, TypeVar
+
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.compiler_keywords import (
+    EXPANDED_KEYWORD,
+    LAMBDA_KEYWORD,
+)
+from classiq.interface.generator.functions.builtins.internal_operators import (
+    WITHIN_APPLY_NAME,
+)
+from classiq.interface.model.model import MAIN_FUNCTION_NAME
+from classiq.interface.model.native_function_definition import (
+    NativeFunctionDefinition,
+)
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_declaration import (
+    PositionalArg,
+)
+from classiq.interface.model.quantum_statement import QuantumStatement
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+from classiq.interface.source_reference import SourceReference
+
+from classiq.model_expansions.capturing.captured_vars import (
+    CapturedVars,
+    validate_captured_directions,
+)
+from classiq.model_expansions.closure import (
+    Closure,
+    FunctionClosure,
+    GenerativeFunctionClosure,
+)
+from classiq.model_expansions.evaluators.quantum_type_utils import (
+    is_signature_monomorphic,
+)
+from classiq.model_expansions.scope import Scope
+from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
+
+ClosureType = TypeVar("ClosureType", bound=Closure)
+
+
+@dataclass
+class Block:
+    statements: list[QuantumStatement] = field(default_factory=list)
+    captured_vars: CapturedVars = field(default_factory=CapturedVars)
+
+    @property
+    def variable_declarations(self) -> list[VariableDeclarationStatement]:
+        return [
+            stmt
+            for stmt in self.statements
+            if isinstance(stmt, VariableDeclarationStatement)
+        ]
+
+
+@dataclass
+class OperationContext(Generic[ClosureType]):
+    closure: ClosureType
+    blocks: dict[str, Block] = field(default_factory=dict)
+
+    @property
+    def name(self) -> str:
+        return self.closure.name
+
+    @property
+    def positional_arg_declarations(self) -> Sequence[PositionalArg]:
+        return self.closure.positional_arg_declarations
+
+    def statements(self, block_name: str) -> list[QuantumStatement]:
+        return self.blocks[block_name].statements
+
+
+@dataclass
+class FunctionContext(OperationContext[FunctionClosure]):
+    @classmethod
+    def create(cls, original_function: FunctionClosure) -> "FunctionContext":
+        return cls(original_function, {"body": Block()})
+
+    @property
+    def body(self) -> list[QuantumStatement]:
+        return self.statements("body")
+
+    @property
+    def is_lambda(self) -> bool:
+        return self.closure.is_lambda
+
+
+class OperationBuilder:
+    def __init__(
+        self, functions_scope: Scope, counted_name_allocator: CountedNameAllocator
+    ) -> None:
+        self._operations: list[OperationContext] = []
+        self._blocks: list[str] = []
+        self._functions_scope = functions_scope
+        self._current_source_ref: Optional[SourceReference] = None
+        self._counted_name_allocator = counted_name_allocator
+
+    @property
+    def current_operation(self) -> Closure:
+        return self._operations[-1].closure
+
+    @property
+    def current_scope(self) -> Scope:
+        return self.current_operation.scope
+
+    @property
+    def current_function(self) -> FunctionClosure:
+        return self._get_last_function(self._operations)
+
+    @property
+    def parent_function(self) -> FunctionClosure:
+        return self._get_last_function(self._operations[:-1])
+
+    @staticmethod
+    def _get_last_function(operations: list[OperationContext]) -> FunctionClosure:
+        for operation in reversed(operations):
+            if isinstance(operation.closure, FunctionClosure):
+                return operation.closure
+        raise ClassiqInternalExpansionError("No function found")
+
+    @property
+    def current_block(self) -> Block:
+        return self._operations[-1].blocks[self._blocks[-1]]
+
+    @property
+    def _current_statements(self) -> list[QuantumStatement]:
+        return self.current_block.statements
+
+    def emit_statement(self, statement: QuantumStatement) -> None:
+        if self._current_source_ref is not None:
+            statement.source_ref = self._current_source_ref
+        self._current_statements.append(statement)
+
+    @property
+    def current_statement(self) -> QuantumStatement:
+        return self._current_statements[-1]
+
+    @contextmanager
+    def block_context(self, block_name: str) -> Iterator[None]:
+        self._blocks.append(block_name)
+        self._operations[-1].blocks[block_name] = Block()
+        yield
+        captured_vars = self.current_block.captured_vars
+        if (
+            not isinstance(self.current_operation, FunctionClosure)
+            and self.current_operation.name != WITHIN_APPLY_NAME
+        ):
+            validate_captured_directions(
+                captured_vars.filter_vars(
+                    self.current_function, self.current_block.variable_declarations
+                ),
+                report_outin=False,
+            )
+        self.current_operation.captured_vars.update(
+            captured_vars.filter_vars(self.current_function)
+        )
+        self._blocks.pop()
+
+    @contextmanager
+    def operation_context(
+        self, original_operation: Closure
+    ) -> Iterator[OperationContext]:
+        context: OperationContext
+        if isinstance(original_operation, FunctionClosure):
+            context = FunctionContext.create(original_operation)
+        else:
+            context = OperationContext(closure=original_operation)
+        self._operations.append(context)
+        yield context
+        self._finalize_within_apply()
+        self._propagate_captured_vars()
+        self._operations.pop()
+
+    def _finalize_within_apply(self) -> None:
+        if self.current_operation.name != WITHIN_APPLY_NAME:
+            return
+        within_captured_vars = self._operations[-1].blocks["within"].captured_vars
+        self.current_operation.captured_vars.update(
+            within_captured_vars.filter_vars(self.current_function).negate()
+        )
+
+    def _propagate_captured_vars(self) -> None:
+        captured_vars = self.current_operation.captured_vars
+        if isinstance(self.current_operation, FunctionClosure):
+            captured_vars = captured_vars.set_propagated()
+        validate_captured_directions(captured_vars)
+        if len(self._operations) < 2:
+            return
+        parent_block = self._operations[-2].blocks[self._blocks[-1]]
+        parent_block.captured_vars.update(
+            captured_vars.filter_vars(self.parent_function)
+        )
+
+    @contextmanager
+    def source_ref_context(
+        self, source_ref: Optional[SourceReference]
+    ) -> Iterator[None]:
+        previous_source_ref = self._current_source_ref
+        self._current_source_ref = source_ref
+        yield
+        self._current_source_ref = previous_source_ref
+
+    def create_definition(
+        self, function_context: FunctionContext
+    ) -> NativeFunctionDefinition:
+        name = self._get_expanded_function_name(function_context)
+        new_parameters: list[PortDeclaration] = [
+            param
+            for param in function_context.positional_arg_declarations
+            if isinstance(param, PortDeclaration)
+        ]
+
+        return NativeFunctionDefinition(
+            name=name,
+            body=function_context.body,
+            positional_arg_declarations=new_parameters,
+        )
+
+    def _get_expanded_function_name(self, function_context: FunctionContext) -> str:
+        name = function_context.name
+
+        if name == MAIN_FUNCTION_NAME:
+            return name
+
+        if name in self.current_scope:
+            orig_func = self.current_scope[name].value
+            if (
+                isinstance(orig_func, FunctionClosure)
+                and not isinstance(orig_func, GenerativeFunctionClosure)
+                and is_signature_monomorphic(orig_func.positional_arg_declarations)
+            ):
+                return name
+
+        for _ in self.current_scope:
+            name = self._counted_name_allocator.allocate(
+                f"{name}_{LAMBDA_KEYWORD + '_0_0_' if function_context.is_lambda else ''}{EXPANDED_KEYWORD}"
+            )
+            if name not in self.current_scope:
+                break
+        else:
+            raise ClassiqInternalExpansionError("Could not allocate function name")
+
+        return name

classiq/model_expansions/generative_functions.py

@@ -0,0 +1,158 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any
+
+from classiq.interface.generator.expressions.qmod_struct_instance import (
+    QmodStructInstance,
+)
+from classiq.interface.generator.functions.type_name import Struct
+from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_declaration import (
+    PositionalArg,
+    QuantumFunctionDeclaration,
+    QuantumOperandDeclaration,
+)
+from classiq.interface.model.quantum_statement import QuantumStatement
+
+from classiq.model_expansions.closure import (
+    FunctionClosure,
+    GenerativeClosure,
+)
+from classiq.model_expansions.scope import Evaluated, QuantumSymbol
+from classiq.qmod.generative import generative_mode_context, set_frontend_interpreter
+from classiq.qmod.model_state_container import QMODULE
+from classiq.qmod.qmod_parameter import CParamStruct
+from classiq.qmod.qmod_variable import QNum, _create_qvar_for_qtype
+from classiq.qmod.quantum_callable import QCallable
+from classiq.qmod.quantum_expandable import (
+    QExpandable,
+    QTerminalCallable,
+)
+from classiq.qmod.quantum_function import QFunc
+from classiq.qmod.semantics.annotation.call_annotation import resolve_function_calls
+from classiq.qmod.symbolic_expr import SymbolicExpr
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.generative_interpreter import (
+        GenerativeInterpreter,
+    )
+
+
+class LenList(list):
+    @property
+    def len(self) -> int:
+        return len(self)
+
+    def __getitem__(self, item: Any) -> Any:
+        if isinstance(item, QNum):
+            return SymbolicExpr(f"{self}[{item}]", True)
+        return super().__getitem__(item)
+
+    @classmethod
+    def wrap(cls, obj: Any) -> Any:
+        if not isinstance(obj, list):
+            return obj
+        return LenList([cls.wrap(item) for item in obj])
+
+
+def translate_ast_arg_to_python_qmod(param: PositionalArg, evaluated: Evaluated) -> Any:
+    if isinstance(param, PortDeclaration):
+        quantum_symbol = evaluated.as_type(QuantumSymbol)
+        return _create_qvar_for_qtype(
+            quantum_symbol.quantum_type, quantum_symbol.handle
+        )
+    if isinstance(param, QuantumOperandDeclaration):
+        if param.is_list:
+            func_list: list[FunctionClosure] = evaluated.as_type(list)
+            return LenList(
+                [
+                    QTerminalCallable(
+                        QuantumOperandDeclaration(
+                            name=param.name,
+                            positional_arg_declarations=param.positional_arg_declarations,
+                        ),
+                        index_=idx,
+                    )
+                    for idx in range(len(func_list))
+                ]
+            )
+        else:
+            func = evaluated.as_type(FunctionClosure)
+            return QTerminalCallable(
+                QuantumFunctionDeclaration(
+                    name=param.name if func.is_lambda else func.name,
+                    positional_arg_declarations=func.positional_arg_declarations,
+                ),
+            )
+    classical_value = evaluated.value
+    if isinstance(classical_value, QmodStructInstance):
+        return CParamStruct(
+            expr=param.name,
+            struct_type=Struct(name=classical_value.struct_declaration.name),
+            qmodule=QMODULE,
+        )
+    return LenList.wrap(classical_value)
+
+
+class _InterpreterExpandable(QFunc):
+    def __init__(self, interpreter: "GenerativeInterpreter"):
+        super().__init__(lambda: None)
+        self._interpreter = interpreter
+
+    def append_statement_to_body(self, stmt: QuantumStatement) -> None:
+        current_operation = self._interpreter._builder._operations[-1]
+        dummy_function = NativeFunctionDefinition(
+            name=current_operation.name,
+            positional_arg_declarations=current_operation.positional_arg_declarations,
+            body=self._interpreter._builder._current_statements + [stmt],
+        )
+        declarative_functions = {
+            name: func
+            for name, func in self._qmodule.native_defs.items()
+            if name not in self._interpreter._top_level_scope
+        }
+        self._interpreter.update_declarative_functions(
+            declarative_functions, self._qmodule
+        )
+        self._interpreter.update_generative_functions(
+            self._qmodule.generative_functions
+        )
+        func_decls = self._get_function_declarations()
+        for dec_func in declarative_functions.values():
+            resolve_function_calls(dec_func, func_decls)
+        resolve_function_calls(dummy_function, func_decls)
+        stmt = dummy_function.body[-1]
+        with generative_mode_context(False):
+            self._interpreter.emit_statement(stmt)
+
+    def _get_function_declarations(self) -> Mapping[str, QuantumFunctionDeclaration]:
+        return {
+            name: QuantumFunctionDeclaration(
+                name=name,
+                positional_arg_declarations=evaluated.value.positional_arg_declarations,
+            )
+            for name, evaluated in self._interpreter._builder.current_scope.items()
+            if isinstance(evaluated, Evaluated)
+            and isinstance(evaluated.value, FunctionClosure)
+        } | nameables_to_dict(self._interpreter._get_function_declarations())
+
+
+def emit_generative_statements(
+    interpreter: "GenerativeInterpreter",
+    operation: GenerativeClosure,
+    args: list[Evaluated],
+) -> None:
+    python_qmod_args = [
+        translate_ast_arg_to_python_qmod(param, arg)
+        for param, arg in zip(operation.positional_arg_declarations, args)
+    ]
+    interpreter_expandable = _InterpreterExpandable(interpreter)
+    QExpandable.STACK.append(interpreter_expandable)
+    QCallable.CURRENT_EXPANDABLE = interpreter_expandable
+    set_frontend_interpreter(interpreter)
+    for block_name, generative_function in operation.generative_blocks.items():
+        with interpreter._builder.block_context(block_name), generative_mode_context(
+            True
+        ):
+            generative_function._py_callable(*python_qmod_args)