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

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -0,0 +1,253 @@
+from collections.abc import Mapping
+from enum import Enum
+from typing import Any, Callable, Union
+
+from sympy import Eq, Expr, Number, Piecewise, Symbol
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.expressions.expression_types import (
+    ExpressionValue,
+    QmodStructInstance,
+)
+from classiq.interface.generator.expressions.qmod_qscalar_proxy import QmodQNumProxy
+from classiq.interface.generator.expressions.qmod_qstruct_proxy import QmodQStructProxy
+from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.generator.expressions.type_proxy import TypeProxy
+from classiq.interface.generator.functions.classical_function_declaration import (
+    ClassicalFunctionDeclaration,
+)
+from classiq.interface.generator.functions.classical_type import (
+    Bool,
+    ClassicalList,
+    ClassicalType,
+    OpaqueHandle,
+    QmodPyObject,
+    Real,
+    StructMetaType,
+)
+from classiq.interface.generator.functions.type_name import TypeName
+
+from classiq.model_expansions.model_tables import (
+    HandleIdentifier,
+    HandleTable,
+)
+from classiq.model_expansions.sympy_conversion.arithmetics import (
+    BitwiseAnd,
+    BitwiseNot,
+    BitwiseOr,
+    BitwiseXor,
+    LogicalXor,
+)
+from classiq.model_expansions.sympy_conversion.expression_to_sympy import (
+    MISSING_SLICE_VALUE_PLACEHOLDER,
+)
+from classiq.model_expansions.sympy_conversion.sympy_to_python import (
+    sympy_to_python,
+)
+from classiq.qmod.model_state_container import QMODULE
+
+
+def qmod_val_to_python(val: ExpressionValue, qmod_type: ClassicalType) -> Any:
+    if isinstance(qmod_type, TypeName):
+        if (
+            isinstance(val, QmodStructInstance)
+            and val.struct_declaration == QMODULE.type_decls[qmod_type.name]
+        ):
+            return {
+                field_name: qmod_val_to_python(val.fields[field_name], field_type)
+                for field_name, field_type in val.struct_declaration.variables.items()
+            }
+
+        if isinstance(val, (Enum, int)):
+            return val
+
+    elif isinstance(qmod_type, ClassicalList):
+        if isinstance(val, list):
+            return [qmod_val_to_python(elem, qmod_type.element_type) for elem in val]
+
+    elif isinstance(qmod_type, OpaqueHandle):
+        if isinstance(val, HandleIdentifier):
+            return HandleTable.get_handle_object(val)
+
+    elif isinstance(val, Expr):
+        return sympy_to_python(val)
+
+    elif isinstance(qmod_type, Real):
+        if isinstance(val, (float, int)):
+            return val
+
+    elif isinstance(qmod_type, Bool):
+        if isinstance(val, bool):
+            return val
+
+    elif isinstance(qmod_type, StructMetaType):
+        if isinstance(val, TypeProxy):
+            return val.struct_declaration
+
+    elif isinstance(val, int):  # other scalars are represented as int
+        return val
+
+    raise ClassiqInternalExpansionError(
+        f"Bad value {val!r} of type {type(val)!r} for {qmod_type!r}"
+    )
+
+
+def python_val_to_qmod(val: Any, qmod_type: ClassicalType) -> ExpressionValue:
+    if isinstance(qmod_type, TypeName):
+        if qmod_type.name in QMODULE.enum_decls:
+            return val
+
+        struct_decl = QMODULE.type_decls[qmod_type.name]
+        if not isinstance(val, Mapping):
+            raise ClassiqInternalExpansionError(
+                f"Bad value for struct {struct_decl.name}"
+            )
+        qmod_dict = {
+            field_name: python_val_to_qmod(val[field_name], field_type)
+            for field_name, field_type in struct_decl.variables.items()
+        }
+        return QmodStructInstance(struct_decl, qmod_dict)
+
+    if isinstance(qmod_type, ClassicalList):
+        if not isinstance(val, list):
+            raise ClassiqInternalExpansionError("Bad value for list")
+        return [python_val_to_qmod(elem, qmod_type.element_type) for elem in val]
+
+    if isinstance(qmod_type, OpaqueHandle):
+        if not isinstance(val, QmodPyObject):
+            raise ClassiqInternalExpansionError("Bad value opaque handle")
+        return HandleTable.set_handle_object(val)
+
+    return val
+
+
+def python_call_wrapper(func: Callable, *args: ExpressionValue) -> Any:
+    func_decl = ClassicalFunctionDeclaration.FOREIGN_FUNCTION_DECLARATIONS[
+        func.__name__
+    ]
+    python_args = [
+        qmod_val_to_python(args[idx], param_type.classical_type)
+        for idx, param_type in enumerate(func_decl.param_decls)
+    ]
+    assert func_decl.return_type is not None
+    return python_val_to_qmod(func(*python_args), func_decl.return_type)
+
+
+def struct_literal(struct_type_symbol: Symbol, **kwargs: Any) -> QmodStructInstance:
+    return QmodStructInstance(
+        QMODULE.type_decls[struct_type_symbol.name],
+        {field: sympy_to_python(field_value) for field, field_value in kwargs.items()},
+    )
+
+
+def get_field(
+    proxy: Union[QmodSizedProxy, QmodStructInstance, QmodQStructProxy, list],
+    field: str,
+) -> ExpressionValue:
+    if isinstance(proxy, type) and issubclass(proxy, Enum):
+        return getattr(proxy, field)
+    if isinstance(proxy, Symbol) and not isinstance(proxy, QmodSizedProxy):
+        raise ClassiqExpansionError(
+            f"Cannot evaluate '{proxy}.{field}': Variable {str(proxy)!r} is not "
+            f"initialized"
+        )
+    if isinstance(proxy, list):
+        if field != "len":
+            raise ClassiqExpansionError(
+                f"List {str(proxy)!r} has no attribute {field!r}. "
+                f"Available attributes: len"
+            )
+        return len(proxy)
+    if field not in proxy.fields:
+        if isinstance(proxy, (QmodStructInstance, QmodQStructProxy)):
+            property_name = "field"
+        else:
+            property_name = "attribute"
+        suffix = (
+            f". Available {property_name}s: {', '.join(proxy.fields.keys())}"
+            if len(proxy.fields) > 0
+            else ""
+        )
+        proxy_str = proxy.__name__ if isinstance(proxy, type) else f"{str(proxy)!r}"
+        raise ClassiqExpansionError(
+            f"{proxy.type_name} {proxy_str} has no {property_name} {field!r}{suffix}"
+        )
+    return proxy.fields[field]
+
+
+def get_type(struct_type: Symbol) -> TypeProxy:
+    return TypeProxy(QMODULE.type_decls[struct_type.name])
+
+
+def _unwrap_sympy_numeric(n: Any) -> Any:
+    if not isinstance(n, Number) or not n.is_constant():
+        return n
+    if n.is_Integer:
+        return int(n)
+    return float(n)
+
+
+def do_div(lhs: Any, rhs: Any) -> Any:
+    lhs = _unwrap_sympy_numeric(lhs)
+    rhs = _unwrap_sympy_numeric(rhs)
+    return lhs / rhs
+
+
+def do_subscript(value: Any, index: Any) -> Any:
+    if not isinstance(value, list) or not isinstance(index, QmodQNumProxy):
+        if isinstance(index, (QmodSizedProxy, QmodStructInstance)):
+            raise ClassiqExpansionError(
+                f"Subscript {value}[{index}] is not supported. Supported subscripts "
+                f"include:\n"
+                f"\t1. `qbv[idx]`, where `qbv` is a quantum array and `idx` is a "
+                f"classical integer.\n"
+                f"\t2. `l[n]`, where `l` is a list of classical real numbers and `n` "
+                f"is a classical or quantum integer."
+            )
+        return value[index]
+    if index.is_signed or index.fraction_digits > 0:
+        raise ClassiqExpansionError(
+            "Quantum numeric subscript must be an unsigned integer (is_signed=False, "
+            "fraction_digits=0)"
+        )
+    if len(value) != 2**index.size:
+        raise ClassiqExpansionError(
+            f"Quantum numeric subscript size mismatch: The quantum numeric has "
+            f"{index.size} qubits but the list size is {len(value)} != 2**{index.size}"
+        )
+    return Piecewise(
+        *[(item, Eq(index, idx)) for idx, item in enumerate(value[:-1])],
+        (value[-1], True),
+    )
+
+
+def do_slice(value: Any, lower: Any, upper: Any) -> Any:
+    if isinstance(lower, Symbol) and str(lower) == MISSING_SLICE_VALUE_PLACEHOLDER:
+        lower = None
+    if isinstance(upper, Symbol) and str(upper) == MISSING_SLICE_VALUE_PLACEHOLDER:
+        upper = None
+    return do_subscript(value, slice(lower, upper))
+
+
+CORE_LIB_FUNCTIONS_LIST: list[Callable] = [
+    print,
+    sum,
+    struct_literal,
+    get_field,
+    get_type,
+    do_div,
+    do_slice,
+    do_subscript,
+    BitwiseAnd,
+    BitwiseXor,
+    BitwiseNot,
+    BitwiseOr,
+    LogicalXor,
+]
+
+ATOMIC_EXPRESSION_FUNCTIONS = {
+    **{core_func.__name__: core_func for core_func in CORE_LIB_FUNCTIONS_LIST},
+}

classiq/model_expansions/capturing/captured_vars.py

@@ -0,0 +1,435 @@
+import dataclasses
+from collections.abc import Sequence
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Optional
+
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.handle_binding import (
+    HandleBinding,
+    NestedHandleBinding,
+    SlicedHandleBinding,
+)
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_call import ArgValue
+from classiq.interface.model.quantum_type import QuantumBitvector, QuantumType
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+
+from classiq.model_expansions.capturing.mangling_utils import (
+    demangle_handle,
+    mangle_captured_var_name,
+)
+from classiq.model_expansions.transformers.var_splitter import SymbolPart, SymbolParts
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.closure import FunctionClosure
+
+
+ALREADY_ALLOCATED_MESSAGE = "Cannot allocate variable '{}', it is already initialized"
+ALREADY_FREED_MESSAGE = "Cannot free variable '{}', it is already uninitialized"
+
+
+class PortDirection(StrEnum):
+    Input = "input"
+    Inout = "inout"
+    Output = "output"
+    Outin = "outin"
+
+    def negate(self) -> "PortDirection":
+        if self == PortDirection.Input:
+            return PortDirection.Output
+        if self == PortDirection.Output:
+            return PortDirection.Input
+        return self
+
+    @staticmethod
+    def load(direction: PortDeclarationDirection) -> "PortDirection":
+        if direction == PortDeclarationDirection.Input:
+            return PortDirection.Input
+        if direction == PortDeclarationDirection.Output:
+            return PortDirection.Output
+        if direction == PortDeclarationDirection.Inout:
+            return PortDirection.Inout
+        raise ClassiqInternalExpansionError
+
+    def dump(self) -> PortDeclarationDirection:
+        if self == PortDirection.Input:
+            return PortDeclarationDirection.Input
+        if self == PortDirection.Output:
+            return PortDeclarationDirection.Output
+        if self == PortDirection.Inout:
+            return PortDeclarationDirection.Inout
+        raise ClassiqInternalExpansionError
+
+
+@dataclass(frozen=True)
+class _CapturedHandle:
+    handle: HandleBinding
+    quantum_type: QuantumType
+    defining_function: "FunctionClosure"
+    direction: PortDirection
+    is_propagated: bool
+
+    @property
+    def mangled_name(self) -> str:
+        return mangle_captured_var_name(
+            self.handle.identifier,
+            self.defining_function.name,
+            self.defining_function.depth,
+        )
+
+    @property
+    def port(self) -> PortDeclaration:
+        return PortDeclaration(
+            name=self.mangled_name,
+            quantum_type=self.quantum_type,
+            direction=self.direction.dump(),
+        )
+
+    def is_same_var(self, other: "_CapturedHandle") -> bool:
+        return self.handle.name == other.handle.name and _same_closure(
+            self.defining_function, other.defining_function
+        )
+
+    def change_direction(self, new_direction: PortDirection) -> "_CapturedHandle":
+        return dataclasses.replace(self, direction=new_direction)
+
+    def set_propagated(self) -> "_CapturedHandle":
+        return dataclasses.replace(self, is_propagated=True)
+
+    def update_propagation(
+        self, other_captured_handle: "_CapturedHandle"
+    ) -> "_CapturedHandle":
+        if self.is_propagated and not other_captured_handle.is_propagated:
+            return dataclasses.replace(self, is_propagated=False)
+        return self
+
+    def set_symbol(
+        self, handle: HandleBinding, quantum_type: QuantumType
+    ) -> "_CapturedHandle":
+        return dataclasses.replace(self, handle=handle, quantum_type=quantum_type)
+
+
+@dataclass
+class CapturedVars:
+    _captured_handles: list[_CapturedHandle] = field(default_factory=list)
+
+    def capture_handle(
+        self,
+        handle: HandleBinding,
+        quantum_type: QuantumType,
+        defining_function: "FunctionClosure",
+        direction: PortDeclarationDirection,
+    ) -> None:
+        self._capture_handle(
+            _CapturedHandle(
+                handle=handle,
+                quantum_type=quantum_type,
+                defining_function=defining_function,
+                direction=PortDirection.load(direction),
+                is_propagated=False,
+            )
+        )
+
+    def _capture_handle(self, captured_handle: _CapturedHandle) -> None:
+        if (
+            isinstance(captured_handle.handle, NestedHandleBinding)
+            and captured_handle.direction != PortDirection.Inout
+        ):
+            verb = (
+                "free"
+                if captured_handle.direction == PortDirection.Input
+                else "allocate"
+            )
+            raise ClassiqExpansionError(
+                f"Cannot partially {verb} variable {captured_handle.handle.name}"
+            )
+
+        new_captured_handles = []
+        for existing_captured_handle in self._captured_handles:
+            if not existing_captured_handle.is_same_var(captured_handle):
+                new_captured_handles.append(existing_captured_handle)
+                continue
+            captured_handle = captured_handle.update_propagation(
+                existing_captured_handle
+            )
+            if existing_captured_handle.handle == captured_handle.handle:
+                captured_handle = self._conjugate_direction(
+                    existing_captured_handle, captured_handle
+                )
+            elif captured_handle.handle.overlaps(existing_captured_handle.handle):
+                captured_handle = self._intersect_handles(
+                    existing_captured_handle, captured_handle
+                )
+            else:
+                new_captured_handles.append(existing_captured_handle)
+        new_captured_handles.append(captured_handle)
+        self._captured_handles = new_captured_handles
+
+    def _conjugate_direction(
+        self,
+        existing_captured_handle: _CapturedHandle,
+        captured_handle: _CapturedHandle,
+    ) -> _CapturedHandle:
+        if existing_captured_handle.direction == PortDirection.Input:
+            if captured_handle.direction == PortDirection.Output:
+                return captured_handle.change_direction(PortDirection.Inout)
+            if captured_handle.direction == PortDirection.Outin:
+                return captured_handle.change_direction(PortDirection.Input)
+            raise ClassiqExpansionError(
+                ALREADY_FREED_MESSAGE.format(captured_handle.handle)
+            )
+        if existing_captured_handle.direction == PortDirection.Output:
+            if captured_handle.direction == PortDirection.Input:
+                return captured_handle.change_direction(PortDirection.Outin)
+            if captured_handle.direction in (
+                PortDirection.Output,
+                PortDirection.Outin,
+            ):
+                raise ClassiqExpansionError(
+                    ALREADY_ALLOCATED_MESSAGE.format(captured_handle.handle)
+                )
+            return captured_handle.change_direction(PortDirection.Output)
+        if existing_captured_handle.direction == PortDirection.Inout:
+            if captured_handle.direction in (
+                PortDirection.Output,
+                PortDirection.Outin,
+            ):
+                raise ClassiqExpansionError(
+                    ALREADY_ALLOCATED_MESSAGE.format(captured_handle.handle)
+                )
+        elif captured_handle.direction in (
+            PortDirection.Input,
+            PortDirection.Inout,
+        ):
+            raise ClassiqExpansionError(
+                ALREADY_FREED_MESSAGE.format(captured_handle.handle)
+            )
+        return captured_handle
+
+    def _intersect_handles(
+        self,
+        existing_captured_handle: _CapturedHandle,
+        captured_handle: _CapturedHandle,
+    ) -> _CapturedHandle:
+        if captured_handle.handle in existing_captured_handle.handle:
+            if existing_captured_handle.direction in (
+                PortDirection.Input,
+                PortDirection.Outin,
+            ):
+                raise ClassiqExpansionError(
+                    ALREADY_FREED_MESSAGE.format(captured_handle.handle)
+                )
+            return existing_captured_handle
+
+        if existing_captured_handle.handle in captured_handle.handle:
+            if captured_handle.direction in (
+                PortDirection.Output,
+                PortDirection.Outin,
+            ):
+                raise ClassiqExpansionError(
+                    ALREADY_ALLOCATED_MESSAGE.format(captured_handle.handle)
+                )
+            return captured_handle
+
+        sliced_handle, quantum_type, other_handle = self._get_sliced_handle(
+            existing_captured_handle, captured_handle
+        )
+        if not isinstance(other_handle, SlicedHandleBinding):
+            return captured_handle.set_symbol(sliced_handle, quantum_type)
+
+        merged_handle, merged_quantum_type = self._merge_sliced_handles(
+            sliced_handle, other_handle, quantum_type
+        )
+        return captured_handle.set_symbol(merged_handle, merged_quantum_type)
+
+    @staticmethod
+    def _get_sliced_handle(
+        existing_captured_handle: _CapturedHandle,
+        captured_handle: _CapturedHandle,
+    ) -> tuple[SlicedHandleBinding, QuantumBitvector, HandleBinding]:
+        handle_1 = existing_captured_handle.handle
+        quantum_type_1 = existing_captured_handle.quantum_type
+        handle_2 = captured_handle.handle
+        quantum_type_2 = captured_handle.quantum_type
+        if isinstance(handle_1, SlicedHandleBinding):
+            sliced_handle = handle_1
+            other_handle = handle_2
+            quantum_type = quantum_type_1
+        elif isinstance(handle_2, SlicedHandleBinding):
+            sliced_handle = handle_2
+            other_handle = handle_1
+            quantum_type = quantum_type_2
+        else:
+            raise ClassiqInternalExpansionError(
+                f"Unexpected overlapping handles {handle_1} and {handle_2}"
+            )
+        if not isinstance(quantum_type, QuantumBitvector):
+            raise ClassiqInternalExpansionError
+        return sliced_handle, quantum_type, other_handle
+
+    @staticmethod
+    def _merge_sliced_handles(
+        handle_1: SlicedHandleBinding,
+        handle_2: SlicedHandleBinding,
+        quantum_type: QuantumBitvector,
+    ) -> tuple[HandleBinding, QuantumBitvector]:
+        if (
+            not handle_1.start.is_evaluated()
+            or not handle_1.end.is_evaluated()
+            or not handle_2.start.is_evaluated()
+            or not handle_2.end.is_evaluated()
+        ):
+            raise ClassiqInternalExpansionError
+
+        new_start = min(handle_1.start.to_int_value(), handle_2.start.to_int_value())
+        new_end = max(handle_1.end.to_int_value(), handle_2.end.to_int_value())
+        merged_handle = SlicedHandleBinding(
+            base_handle=handle_1.base_handle,
+            start=Expression(expr=str(new_start)),
+            end=Expression(expr=str(new_end)),
+        )
+        merged_quantum_type = QuantumBitvector(
+            element_type=quantum_type.element_type,
+            length=Expression(expr=str(new_end - new_start)),
+        )
+        return merged_handle, merged_quantum_type
+
+    def update(self, other_captured_vars: "CapturedVars") -> None:
+        for captured_handle in other_captured_vars._captured_handles:
+            self._capture_handle(captured_handle)
+
+    def negate(self) -> "CapturedVars":
+        return CapturedVars(
+            _captured_handles=[
+                captured_handle.change_direction(captured_handle.direction.negate())
+                for captured_handle in self._captured_handles
+            ]
+        )
+
+    def filter_vars(
+        self,
+        current_function: "FunctionClosure",
+        current_declarations: Optional[list[VariableDeclarationStatement]] = None,
+    ) -> "CapturedVars":
+        current_declared_vars = (
+            None
+            if current_declarations is None
+            else {decl.name for decl in current_declarations}
+        )
+        return CapturedVars(
+            _captured_handles=[
+                captured_handle
+                for captured_handle in self._captured_handles
+                if not _same_closure(
+                    captured_handle.defining_function, current_function
+                )
+                or (
+                    current_declared_vars is not None
+                    and captured_handle.handle.name not in current_declared_vars
+                )
+            ]
+        )
+
+    def set_propagated(self) -> "CapturedVars":
+        return CapturedVars(
+            _captured_handles=[
+                captured_handle.set_propagated()
+                for captured_handle in self._captured_handles
+            ]
+        )
+
+    def get_captured_ports(self) -> list[PortDeclaration]:
+        return [captured_handle.port for captured_handle in self._captured_handles]
+
+    def get_captured_args(
+        self, current_function: "FunctionClosure"
+    ) -> list[HandleBinding]:
+        return [
+            (
+                captured_handle.handle
+                if _same_closure(current_function, captured_handle.defining_function)
+                else HandleBinding(name=captured_handle.mangled_name)
+            )
+            for captured_handle in self._captured_handles
+        ]
+
+    def get_captured_mapping(self) -> SymbolParts:
+        return {
+            captured_handle.handle: [
+                SymbolPart(
+                    source_handle=captured_handle.handle,
+                    target_var_name=captured_handle.mangled_name,
+                    target_var_type=captured_handle.quantum_type,
+                )
+            ]
+            for captured_handle in self._captured_handles
+            if not captured_handle.is_propagated
+        }
+
+    def clone(self) -> "CapturedVars":
+        return CapturedVars(_captured_handles=list(self._captured_handles))
+
+
+def _same_closure(closure_1: "FunctionClosure", closure_2: "FunctionClosure") -> bool:
+    return closure_1.depth == closure_2.depth
+
+
+def validate_args_are_not_propagated(
+    args: Sequence[ArgValue], captured_vars: Sequence[HandleBinding]
+) -> None:
+    if not captured_vars:
+        return
+    captured_handles = {demangle_handle(handle) for handle in captured_vars}
+    arg_handles = {
+        demangle_handle(arg) for arg in args if isinstance(arg, HandleBinding)
+    }
+    if any(
+        arg_handle.overlaps(captured_handle)
+        for arg_handle in arg_handles
+        for captured_handle in captured_handles
+    ):
+        captured_handles_str = {str(handle) for handle in captured_handles}
+        arg_handles_str = {str(handle) for handle in arg_handles}
+        vars_msg = f"Explicitly passed variables: {arg_handles_str}, captured variables: {captured_handles_str}"
+        raise ClassiqExpansionError(
+            f"Cannot capture variables that are explicitly passed as arguments. "
+            f"{vars_msg}"
+        )
+
+
+def validate_captured_directions(
+    captured_vars: CapturedVars, report_outin: bool = True
+) -> None:
+    captured_inputs = [
+        captured_handle.handle.name
+        for captured_handle in captured_vars._captured_handles
+        if captured_handle.direction == PortDirection.Input
+    ]
+    captured_outputs = [
+        captured_handle.handle.name
+        for captured_handle in captured_vars._captured_handles
+        if captured_handle.direction
+        in (
+            (PortDirection.Output, PortDirection.Outin)
+            if report_outin
+            else (PortDirection.Output,)
+        )
+    ]
+    if len(captured_inputs) > 0:
+        raise ClassiqExpansionError(
+            f"Captured quantum variables {captured_inputs!r} cannot be used as inputs"
+        )
+    if len(captured_outputs) > 0:
+        raise ClassiqExpansionError(
+            f"Captured quantum variables {captured_outputs!r} cannot be used as outputs"
+        )