Migrate StrategyExecutor to new transformer infrastructure

cirq-core/cirq/contrib/acquaintance/__init__.py

@@ -22,6 +22,7 @@
     AcquaintanceOperation,
     GreedyExecutionStrategy,
     StrategyExecutor,
+    StrategyExecutorTransformer,
 )
 
 from cirq.contrib.acquaintance.gates import acquaint, AcquaintanceOpportunityGate, SwapNetworkGate

cirq-core/cirq/contrib/acquaintance/executor.py

@@ -12,12 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import DefaultDict, Dict, Sequence, TYPE_CHECKING, Optional
+from typing import DefaultDict, Dict, Sequence, Optional
 
 import abc
 from collections import defaultdict
 
-from cirq import circuits, devices, ops, protocols
+from cirq import circuits, devices, ops, protocols, transformers
+import cirq
 
 from cirq.contrib.acquaintance.gates import AcquaintanceOpportunityGate
 from cirq.contrib.acquaintance.permutation import (
@@ -29,9 +30,6 @@
 )
 from cirq.contrib.acquaintance.mutation_utils import expose_acquaintance_gates
 
-if TYPE_CHECKING:
-    import cirq
-
 
 class ExecutionStrategy(metaclass=abc.ABCMeta):
     """Tells StrategyExecutor how to execute an acquaintance strategy.
@@ -61,9 +59,26 @@ def get_operations(
         """Gets the logical operations to apply to qubits."""
 
     def __call__(self, *args, **kwargs):
-        return StrategyExecutor(self)(*args, **kwargs)
+        """Returns a copy of the modified circuit and the final mapping of
+        logical indices to qubits
+        """
+        if not isinstance(args[0], circuits.AbstractCircuit):
+            raise ValueError(
+                (
+                    "To call ExecutionStrategy, an argument of type "
+                    "'cirq.Circuit' must be passed in as the first non-keyword argument"
+                )
+            )
+        input_circuit = args[0]
+        strategy = StrategyExecutorTransformer(self)
+        final_circuit = strategy(input_circuit, **kwargs)
+        input_circuit._moments = final_circuit._moments
+        return strategy.get_mapping()
 
 
+@cirq._compat.deprecated_class(
+    deadline='v1.0', fix='Use cirq.contrib.acquaintance.strategy_executor.'
+)
 class StrategyExecutor(circuits.PointOptimizer):
     """Executes an acquaintance strategy."""
 
@@ -100,6 +115,65 @@ def optimization_at(
         )
 
 
+class StrategyExecutorTransformer:
+    """Executes an acquaintance strategy."""
+
+    def __init__(self, execution_strategy: ExecutionStrategy) -> None:
+        self.execution_strategy = execution_strategy
+        self.mapping = execution_strategy.initial_mapping.copy()
+
+    def __call__(
+        self, circuit: 'cirq.Circuit', context: Optional['cirq.TransformerContext'] = None
+    ) -> circuits.AbstractCircuit:
+        """Executes an acquaintance strategy using primitive map function and
+          mutates initial mapping.
+
+        Args:
+            circuit: Input circuit to transform.
+            context: `cirq.TransformerContext` storing common configurable
+              options for transformers.
+
+        Raises:
+            ValueError: if execution_strategy is None
+            TypeError: if execution_strategy neither an instance of
+              AcquaintanceOpportunityGate or PermutationGate
+
+        Returns:
+            A copy of the modified circuit after executing an acquaintance
+              strategy on all instances of AcquaintanceOpportunityGate
+        """
+
+        if self.execution_strategy is None:
+            raise ValueError('execution_strategy cannot be None')
+        expose_acquaintance_gates(circuit)
+        return transformers.map_operations(
+            circuit=circuit,
+            map_func=self.map_func,
+            deep=context.deep if context else False,
+            tags_to_ignore=context.tags_to_ignore if context else (),
+        )
+
+    def get_mapping(self):
+        return self.mapping.copy()
+
+    def map_func(self, op: 'cirq.Operation', index) -> 'cirq.OP_TREE':
+        if isinstance(op.gate, AcquaintanceOpportunityGate):
+            logical_indices = tuple(self.mapping[q] for q in op.qubits)
+            logical_operations = self.execution_strategy.get_operations(logical_indices, op.qubits)
+            clear_span = int(not self.execution_strategy.keep_acquaintance)
+            return logical_operations if clear_span else [op, logical_operations]
+
+        if isinstance(op.gate, PermutationGate):
+            op.gate.update_mapping(self.mapping, op.qubits)
+            return op
+
+        raise TypeError(
+            'Can only execute a strategy consisting of gates that '
+            'are instances of AcquaintanceOpportunityGate or '
+            'PermutationGate.'
+        )
+
+
 class AcquaintanceOperation(ops.GateOperation):
     """Represents an a acquaintance opportunity between a particular set of
     logical indices on a particular set of physical qubits.

cirq-core/cirq/contrib/acquaintance/executor_test.py

@@ -48,7 +48,10 @@ def test_executor_explicit():
     }
     initial_mapping = {q: i for i, q in enumerate(sorted(qubits))}
     execution_strategy = cca.GreedyExecutionStrategy(gates, initial_mapping)
-    executor = cca.StrategyExecutor(execution_strategy)
+    with cirq.testing.assert_deprecated(
+        "Use cirq.contrib.acquaintance.strategy_executor", deadline='v1.0'
+    ):
+        executor = cca.StrategyExecutor(execution_strategy)
 
     with pytest.raises(NotImplementedError):
         bad_gates = {(0,): ExampleGate(['0']), (0, 1): ExampleGate(['0', '1'])}