classiq 0.84.0__py3-none-any.whl → 0.85.0__py3-none-any.whl

classiq/applications/combinatorial_optimization/combinatorial_problem.py

@@ -1,12 +1,11 @@
 import math
 import re
-from typing import Callable, Optional
+from typing import Callable, Optional, cast
 
 import numpy as np
 import pandas as pd
 import pyomo.core as pyo
 import scipy
-from tqdm import tqdm
 
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.executor.result import ExecutionDetails
@@ -44,8 +43,8 @@ class CombinatorialProblem:
         self.num_layers_ = num_layers
         self.model_ = None
         self.qprog_ = None
-        self.es_ = None
-        self.optimized_params_ = None
+        self._es: ExecutionSession | None = None
+        self._optimized_params: list[float] | None = None
         self.params_trace_: list[np.ndarray] = []
         self.cost_trace_: list = []
 
@@ -58,8 +57,8 @@ class CombinatorialProblem:
         return self.params_trace_
 
     @property
-    def optimized_params(self) -> list:
-        return self.optimized_params_  # type:ignore[return-value]
+    def optimized_params(self) -> list[float]:
+        return self._optimized_params  # type:ignore[return-value]
 
     def get_model(
         self,
@@ -100,22 +99,9 @@ class CombinatorialProblem:
     ) -> list[float]:
         if self.qprog_ is None:
             self.get_qprog()
-        self.es_ = ExecutionSession(
-            self.qprog_, execution_preferences  # type:ignore[assignment,arg-type]
+        _es = ExecutionSession(
+            self.qprog_, execution_preferences  # type:ignore[arg-type]
         )
-        self.params_trace_ = []
-        self.cost_trace_ = []
-
-        def estimate_cost_wrapper(params: np.ndarray) -> float:
-            cost = self.es_.estimate_cost(  # type:ignore[attr-defined]
-                lambda state: self.cost_func(state["v"]),
-                {"params": params.tolist()},
-                quantile=quantile,
-            )
-            self.cost_trace_.append(cost)
-            self.params_trace_.append(params)
-            return cost
-
         initial_params = (
             np.concatenate(
                 (
@@ -125,31 +111,23 @@ class CombinatorialProblem:
             )
             * math.pi
         )
-
-        with tqdm(total=maxiter, desc="Optimization Progress", leave=True) as pbar:
-
-            def _minimze_callback(xk: np.ndarray) -> None:
-                pbar.update(1)  # increment progress bar
-                self.optimized_params_ = xk.tolist()  # save recent optimized value
-
-            self.optimized_params_ = scipy.optimize.minimize(
-                estimate_cost_wrapper,
-                callback=_minimze_callback,
-                x0=initial_params,
-                method="COBYLA",
-                options={"maxiter": maxiter},
-            ).x.tolist()
-
-        return self.optimized_params_  # type:ignore[return-value]
+        result = _es.minimize(
+            lambda v: self.cost_func(v),  # type:ignore[arg-type]
+            {"params": initial_params.tolist()},
+            maxiter,
+            quantile,
+        )
+        _optimized_params = cast(list[float], result[-1][1]["params"])
+        self._optimized_params = _optimized_params
+        self._es = _es
+        return _optimized_params
 
     def sample_uniform(self) -> pd.DataFrame:
         return self.sample([0] * self.num_layers_ * 2)
 
     def sample(self, params: list) -> pd.DataFrame:
-        assert self.es_ is not None
-        res = self.es_.sample(  # type:ignore[unreachable]
-            {"params": params}
-        )
+        assert self._es is not None
+        res = self._es.sample({"params": params})
         parsed_result = [
             {
                 "solution": {
@@ -157,7 +135,7 @@ class CombinatorialProblem:
                     for key, value in sampled.state["v"].items()
                     if not re.match(".*_slack_var_.*", key)
                 },
-                "probability": sampled.shots / res.num_shots,
+                "probability": sampled.shots / res.num_shots,  # type:ignore[operator]
                 "cost": self.cost_func(sampled.state["v"]),
             }
             for sampled in res.parsed_counts

classiq/evaluators/classical_expression.py

@@ -11,26 +11,43 @@ from classiq.interface.generator.expressions.proxies.classical.any_classical_val
 from classiq.interface.model.handle_binding import HandleBinding
 
 from classiq.evaluators.expression_evaluator import evaluate
-from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+from classiq.model_expansions.scope import (
+    ClassicalSymbol,
+    Evaluated,
+    QuantumSymbol,
+    Scope,
+)
 
 
 def evaluate_classical_expression(expr: Expression, scope: Scope) -> Evaluated:
     all_symbols = scope.items()
-    locals_dict = {
-        name: EvaluatedExpression(value=evaluated.value)
-        for name, evaluated in all_symbols
-        if isinstance(evaluated.value, get_args(ExpressionValue))
-    } | {
-        name: EvaluatedExpression(
-            value=(
-                evaluated.value.quantum_type.get_proxy(HandleBinding(name=name))
-                if evaluated.value.quantum_type.is_evaluated
-                else AnyClassicalValue(name)
+    locals_dict = (
+        {
+            name: EvaluatedExpression(value=evaluated.value)
+            for name, evaluated in all_symbols
+            if isinstance(evaluated.value, get_args(ExpressionValue))
+        }
+        | {
+            name: EvaluatedExpression(
+                value=(
+                    evaluated.value.quantum_type.get_proxy(HandleBinding(name=name))
+                    if evaluated.value.quantum_type.is_evaluated
+                    else AnyClassicalValue(name)
+                )
+            )
+            for name, evaluated in all_symbols
+            if isinstance(evaluated.value, QuantumSymbol)
+        }
+        | {
+            name: EvaluatedExpression(
+                value=evaluated.value.classical_type.get_classical_proxy(
+                    HandleBinding(name=name)
+                )
             )
-        )
-        for name, evaluated in all_symbols
-        if isinstance(evaluated.value, QuantumSymbol)
-    }
+            for name, evaluated in all_symbols
+            if isinstance(evaluated.value, ClassicalSymbol)
+        }
+    )
 
     ret = evaluate(expr, locals_dict)
     return Evaluated(value=ret.value)

classiq/execution/execution_session.py

@@ -1,10 +1,15 @@
 import inspect
 import random
+import warnings
 from types import TracebackType
-from typing import Callable, Optional, Union, cast
+from typing import Any, Callable, Optional, Union, cast
 
 from classiq.interface.chemistry.operator import PauliOperator, pauli_integers_to_str
-from classiq.interface.exceptions import ClassiqError, ClassiqValueError
+from classiq.interface.exceptions import (
+    ClassiqDeprecationWarning,
+    ClassiqError,
+    ClassiqValueError,
+)
 from classiq.interface.execution.primitives import (
     EstimateInput,
     MinimizeClassicalCostInput,
@@ -71,6 +76,20 @@ def parse_params(params: ExecutionParams) -> ParsedExecutionParams:
     return result
 
 
+def _hamiltonian_deprecation_warning(hamiltonian: Any) -> None:
+    if isinstance(hamiltonian, list):
+        warnings.warn(
+            (
+                "Parameter type list[PauliTerm] to 'ExecutionSession' methods is "
+                "deprecated and will no longer be supported starting on 21/7/2025 "
+                "at the earliest. Instead, send a 'SparsePauliOp' (see "
+                "https://docs.classiq.io/latest/qmod-reference/language-reference/classical-types/#hamiltonians)."
+            ),
+            ClassiqDeprecationWarning,
+            stacklevel=3,
+        )
+
+
 class ExecutionSession:
     """
     A session for executing a quantum program.
@@ -228,11 +247,18 @@ class ExecutionSession:
         Returns:
             EstimationResult: The result of the estimation.
         """
-        job = self.submit_estimate(hamiltonian=hamiltonian, parameters=parameters)
+        _hamiltonian_deprecation_warning(hamiltonian)
+        job = self.submit_estimate(
+            hamiltonian=hamiltonian, parameters=parameters, _check_deprecation=False
+        )
         return job.get_estimate_result(_http_client=self._async_client)
 
     def submit_estimate(
-        self, hamiltonian: Hamiltonian, parameters: Optional[ExecutionParams] = None
+        self,
+        hamiltonian: Hamiltonian,
+        parameters: Optional[ExecutionParams] = None,
+        *,
+        _check_deprecation: bool = True,
     ) -> ExecutionJob:
         """
         Initiates an execution job with the `estimate` primitive.
@@ -247,6 +273,8 @@ class ExecutionSession:
         Returns:
             The execution job.
         """
+        if _check_deprecation:
+            _hamiltonian_deprecation_warning(hamiltonian)
         execution_primitives_input = PrimitivesInput(
             estimate=EstimateInput(
                 hamiltonian=self._hamiltonian_to_pauli_operator(hamiltonian),
@@ -270,11 +298,18 @@ class ExecutionSession:
         Returns:
             List[EstimationResult]: The results of all the estimation iterations.
         """
-        job = self.submit_batch_estimate(hamiltonian=hamiltonian, parameters=parameters)
+        _hamiltonian_deprecation_warning(hamiltonian)
+        job = self.submit_batch_estimate(
+            hamiltonian=hamiltonian, parameters=parameters, _check_deprecation=False
+        )
         return job.get_batch_estimate_result(_http_client=self._async_client)
 
     def submit_batch_estimate(
-        self, hamiltonian: Hamiltonian, parameters: list[ExecutionParams]
+        self,
+        hamiltonian: Hamiltonian,
+        parameters: list[ExecutionParams],
+        *,
+        _check_deprecation: bool = True,
     ) -> ExecutionJob:
         """
         Initiates an execution job with the `batch_estimate` primitive.
@@ -289,6 +324,8 @@ class ExecutionSession:
         Returns:
             The execution job.
         """
+        if _check_deprecation:
+            _hamiltonian_deprecation_warning(hamiltonian)
         execution_primitives_input = PrimitivesInput(
             estimate=EstimateInput(
                 hamiltonian=self._hamiltonian_to_pauli_operator(hamiltonian),
@@ -322,11 +359,13 @@ class ExecutionSession:
             A list of tuples, each containing the estimated cost and the corresponding parameters for that iteration.
             `cost` is a float, and `parameters` is a dictionary matching the execution parameter format.
         """
+        _hamiltonian_deprecation_warning(cost_function)
         job = self.submit_minimize(
             cost_function=cost_function,
             initial_params=initial_params,
             max_iteration=max_iteration,
             quantile=quantile,
+            _check_deprecation=False,
         )
         result = job.get_minimization_result(_http_client=self._async_client)
 
@@ -340,6 +379,8 @@ class ExecutionSession:
         initial_params: ExecutionParams,
         max_iteration: int,
         quantile: float = 1.0,
+        *,
+        _check_deprecation: bool = True,
     ) -> ExecutionJob:
         """
         Initiates an execution job with the `minimize` primitive.
@@ -363,6 +404,8 @@ class ExecutionSession:
         Returns:
             The execution job.
         """
+        if _check_deprecation:
+            _hamiltonian_deprecation_warning(cost_function)
         if len(initial_params) != 1:
             raise ClassiqValueError(
                 "The initial parameters must be a dictionary with a single key-value pair."

classiq/interface/_version.py

@@ -3,5 +3,5 @@ from packaging.version import Version
 # This file was generated automatically
 # Please don't track in version control (DONTTRACK)
 
-SEMVER_VERSION = '0.84.0'
+SEMVER_VERSION = '0.85.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/debug_info/debug_info.py

@@ -9,7 +9,6 @@ from classiq.interface.generator.generated_circuit_data import (
     FunctionDebugInfoInterface,
     StatementType,
 )
-from classiq.interface.model.block import Block
 from classiq.interface.model.handle_binding import ConcreteHandleBinding
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import ArgValue
@@ -82,9 +81,6 @@ def get_back_refs(
 ) -> list[ConcreteQuantumStatement]:
     back_refs: list[ConcreteQuantumStatement] = []
     while (node := debug_info.node) is not None:
-        #  For backwards compatibility, we make sure that the back_ref is not a block
-        #  Remove this check when we start saving blocks in the debug info collection.
-        assert not isinstance(node, Block)
         if len(back_refs) > 0 and node.back_ref == back_refs[0].back_ref:
             break
         back_refs.insert(0, node)

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -20,9 +20,14 @@ CLASSIQ_EXPR_FUNCTIONS = {
     "get_field",
 }
 
+MEASUREMENT_FUNCTIONS = {
+    "measure",
+}
+
 SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS = {
     *CLASSIQ_BUILTIN_CLASSICAL_FUNCTIONS,
     *CLASSIQ_EXPR_FUNCTIONS,
+    *MEASUREMENT_FUNCTIONS,
 }
 
 SUPPORTED_CLASSIQ_SYMPY_WRAPPERS = {

classiq/interface/generator/functions/builtins/internal_operators.py

@@ -6,6 +6,7 @@ CLASSICAL_IF_OPERATOR_NAME = "classical_if"
 POWER_OPERATOR_NAME = "power"
 UNCOMPUTE_OPERATOR_NAME = "uncompute"
 WITHIN_APPLY_NAME = "within_apply"
+BLOCK_OPERATOR_NAME = "block"
 
 All_BUILTINS_OPERATORS = {
     CONTROL_OPERATOR_NAME,
@@ -14,4 +15,5 @@ All_BUILTINS_OPERATORS = {
     POWER_OPERATOR_NAME,
     UNCOMPUTE_OPERATOR_NAME,
     WITHIN_APPLY_NAME,
+    BLOCK_OPERATOR_NAME,
 }

classiq/interface/generator/functions/concrete_types.py

@@ -53,3 +53,23 @@ QuantumBitvector.model_rebuild()
 TypeName.model_rebuild()
 QStructDeclaration.model_rebuild()
 RegisterQuantumType.model_rebuild()
+
+ConcreteType = Annotated[
+    Union[
+        Integer,
+        Real,
+        Bool,
+        StructMetaType,
+        TypeName,
+        ClassicalArray,
+        ClassicalTuple,
+        VQEResult,
+        Histogram,
+        Estimation,
+        IQAERes,
+        QuantumBit,
+        QuantumBitvector,
+        QuantumNumeric,
+    ],
+    Field(discriminator="kind"),
+]

classiq/interface/generator/generated_circuit_data.py

@@ -52,8 +52,6 @@ VISUALIZATION_HIDE_LIST = [
     "stmt_block",
 ]
 
-CONTROLLED_PREFIX = "c_"
-
 
 def last_name_in_call_hierarchy(name: str) -> str:
     return name.split(CLASSIQ_HIERARCHY_SEPARATOR)[-1]
@@ -147,6 +145,7 @@ class StatementType(StrEnum):
     INPLACE_XOR = "inplace xor"
     INPLACE_ADD = "inplace add"
     REPEAT = "repeat"
+    BLOCK = "block"
 
 
 # Mapping between statement kind (or sub-kind) and statement type (visualization name)
@@ -167,6 +166,7 @@ STATEMENTS_NAME: dict[str, StatementType] = {
     ArithmeticOperationKind.InplaceXor.value: StatementType.INPLACE_XOR,
     ArithmeticOperationKind.InplaceAdd.value: StatementType.INPLACE_ADD,
     "Repeat": StatementType.REPEAT,
+    "Block": StatementType.BLOCK,
 }
 
 
@@ -207,8 +207,7 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
                 ARITH_ENGINE_PREFIX
             )
             name_with_suffix = self.add_suffix_from_generated_name(generated_name, name)
-            modified_name = self.modify_name_for_controlled_qfunc(name_with_suffix)
-            return modified_name
+            return name_with_suffix
 
         statement_kind: str = back_ref.kind
         if isinstance(back_ref, ArithmeticOperation):
@@ -217,11 +216,6 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
             generated_name, STATEMENTS_NAME[statement_kind]
         )
 
-    def modify_name_for_controlled_qfunc(self, generated_name: str) -> str:
-        if self.control_variable is None:
-            return generated_name
-        return f"{CONTROLLED_PREFIX}{generated_name}"
-
     def add_suffix_from_generated_name(self, generated_name: str, name: str) -> str:
         if part_match := PART_SUFFIX_REGEX.match(generated_name):
             suffix = f" [{part_match.group(1)}]"
@@ -272,7 +266,8 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
             for register in self.registers
             for qubit in register.qubit_indexes_absolute
             if register.role is RegisterRole.INPUT
-            and register.name == self.control_variable
+            and self.port_to_passed_variable_map.get(register.name, register.name)
+            == self.control_variable
         )
 
     def propagate_absolute_qubits(self) -> "FunctionDebugInfoInterface":

classiq/interface/ide/operation_registry.py

@@ -0,0 +1,45 @@
+from typing import Any
+
+from classiq.interface.ide.visual_model import Operation
+
+
+class OperationRegistry:
+    def __init__(self) -> None:
+        self._operation_hash_to_op_id: dict[int, int] = {}
+        self._id_to_operations: dict[int, Operation] = {}
+        self._unique_op_counter = 0
+        self._deduped_op_counter = 0
+
+    def build_operation(self, **kwargs: Any) -> Operation:
+        operation = Operation(**kwargs)
+        return self.add_operation(operation)
+
+    def add_operation(self, op: Operation) -> Operation:
+        """
+        Adds an operation to the global dictionaries for operations.
+        if operation already exist in the registry, it returns the existing operation.
+        """
+        op_hash = hash(op)
+        if op_hash not in self._operation_hash_to_op_id:
+            self._operation_hash_to_op_id[op_hash] = op.id
+            self._id_to_operations[op.id] = op
+            self._unique_op_counter += 1
+        else:
+            self._deduped_op_counter += 1
+            op = self._id_to_operations[self._operation_hash_to_op_id[op_hash]]
+        return op
+
+    def get_operation_mapping(self) -> dict[int, Operation]:
+        return self._id_to_operations
+
+    def get_operations(self, op_ids: list[int]) -> list[Operation]:
+        """
+        Returns a list of operations based on their IDs.
+        """
+        return [self._id_to_operations[op_id] for op_id in op_ids]
+
+    def get_unique_op_number(self) -> int:
+        return self._unique_op_counter
+
+    def get_deduped_op_number(self) -> int:
+        return self._deduped_op_counter

classiq/interface/ide/visual_model.py

@@ -1,5 +1,8 @@
+import json
 from collections import Counter
+from collections.abc import Iterator
 from functools import cached_property
+from itertools import count
 from typing import Any, Optional
 
 import pydantic
@@ -13,6 +16,26 @@ from classiq.interface.generator.hardware.hardware_data import SynthesisHardware
 from classiq.interface.helpers.versioned_model import VersionedModel
 
 
+class OperationIdCounter:
+    _op_id_counter: Iterator[int] = count()
+
+    def next_id(self) -> int:
+        return next(self._op_id_counter)
+
+    def reset_operation_counter(self) -> None:
+        self._op_id_counter = count()
+
+
+_operation_id_counter = OperationIdCounter()
+
+
+def reset_operation_counter() -> None:
+    """
+    Call this at the start of every new task to restart ids at 0.
+    """
+    _operation_id_counter.reset_operation_counter()
+
+
 class OperationType(StrEnum):
     REGULAR = "REGULAR"
     INVISIBLE = "INVISIBLE"
@@ -108,6 +131,7 @@ class AtomicGate(StrEnum):
 
 class Operation(pydantic.BaseModel):
     name: str
+    _id: int = pydantic.PrivateAttr(default_factory=_operation_id_counter.next_id)
     qasm_name: str = pydantic.Field(default="")
     details: str = pydantic.Field(default="")
     children: list["Operation"] = pydantic.Field(default_factory=list)
@@ -120,7 +144,7 @@ class Operation(pydantic.BaseModel):
     target_qubits: tuple[int, ...]
     operation_level: OperationLevel
     operation_type: OperationType = pydantic.Field(
-        description="Identifies unique operations that are visualized differently"
+        description="Identifies unique operations that are visualized differently",
     )
     gate: AtomicGate = pydantic.Field(
         default=AtomicGate.UNKNOWN, description="Gate type"
@@ -129,9 +153,46 @@ class Operation(pydantic.BaseModel):
     expanded: bool = pydantic.Field(default=False)
     show_expanded_label: bool = pydantic.Field(default=False)
 
+    @property
+    def id(self) -> int:
+        return self._id
+
+    def __hash__(self) -> int:
+        """
+        using a custom hashable_dict in order to compare the operation
+        with the qubits in order
+        """
+        js = json.dumps(
+            self._hashable_dict(),
+            sort_keys=True,
+            default=lambda o: o.value if hasattr(o, "value") else str(o),
+        )
+        return hash(js)
+
+    def __eq__(self, other: object) -> bool:
+        return (
+            isinstance(other, Operation)
+            and self._hashable_dict() == other._hashable_dict()
+        )
+
+    def _hashable_dict(self) -> dict:
+        data = self.model_dump(
+            exclude_none=True,
+        )
+        # force qubit order for equality
+        for key in ("target_qubits", "auxiliary_qubits", "control_qubits"):
+            data[key] = sorted(data[key])
+        return data
+
 
 class ProgramVisualModel(VersionedModel):
     main_operation: Operation = pydantic.Field(default=None)
     id_to_operations: dict[int, Operation] = pydantic.Field(default_factory=dict)
     main_operation_id: int = pydantic.Field(default=None)
     program_data: ProgramData
+
+    @property
+    def main_op_from_mapping(self) -> Operation:
+        if self.main_operation_id is None:
+            raise ValueError("Main operation ID is not set.")
+        return self.id_to_operations[self.main_operation_id]

classiq/interface/model/bounds.py

@@ -1,6 +1,6 @@
 from typing import Literal, Optional
 
-from classiq.interface.helpers.custom_pydantic_types import PydanticFloatTuple
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.handle_binding import ConcreteHandleBinding
 from classiq.interface.model.quantum_statement import QuantumOperation
 
@@ -9,4 +9,14 @@ class SetBoundsStatement(QuantumOperation):
     kind: Literal["SetBoundsStatement"]
 
     target: ConcreteHandleBinding
-    bounds: Optional[PydanticFloatTuple]
+    lower_bound: Optional[Expression]
+    upper_bound: Optional[Expression]
+
+    @property
+    def expressions(self) -> list[Expression]:
+        exprs = []
+        if self.lower_bound is not None:
+            exprs.append(self.lower_bound)
+        if self.upper_bound is not None:
+            exprs.append(self.upper_bound)
+        return exprs

classiq/interface/model/quantum_expressions/arithmetic_operation.py

@@ -1,6 +1,8 @@
 from collections.abc import Mapping, Sequence
 from typing import Literal
 
+from pydantic import PrivateAttr
+
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.arith.arithmetic import (
     ARITHMETIC_EXPRESSION_RESULT_NAME,
@@ -27,6 +29,7 @@ class ArithmeticOperation(QuantumAssignmentOperation):
     kind: Literal["ArithmeticOperation"]
 
     operation_kind: ArithmeticOperationKind
+    _classical_assignment: bool = PrivateAttr(default=False)
 
     @property
     def is_inplace(self) -> bool:
@@ -50,7 +53,7 @@ class ArithmeticOperation(QuantumAssignmentOperation):
         self,
     ) -> Mapping[str, ConcreteHandleBinding]:
         inouts = dict(super().wiring_inouts)
-        if self.is_inplace:
+        if self.is_inplace and not self._classical_assignment:
             inouts[self.result_name()] = self.result_var
         return inouts
 
@@ -60,7 +63,7 @@ class ArithmeticOperation(QuantumAssignmentOperation):
             HandleMetadata(handle=handle, readable_location="in an expression")
             for handle in self.var_handles
         ]
-        if self.is_inplace:
+        if self.is_inplace and not self._classical_assignment:
             inouts.append(
                 HandleMetadata(
                     handle=self.result_var,
@@ -71,13 +74,13 @@ class ArithmeticOperation(QuantumAssignmentOperation):
 
     @property
     def wiring_outputs(self) -> Mapping[str, HandleBinding]:
-        if self.is_inplace:
+        if self.is_inplace or self._classical_assignment:
             return {}
         return super().wiring_outputs
 
     @property
     def readable_outputs(self) -> Sequence[HandleMetadata]:
-        if self.is_inplace:
+        if self.is_inplace or self._classical_assignment:
             return []
         return [
             HandleMetadata(