cirq-core 1.5.0.dev20250403170622__py3-none-any.whl → 1.5.0.dev20250404021339__py3-none-any.whl

cirq/circuits/circuit_operation.py

@@ -18,6 +18,9 @@ A CircuitOperation is an Operation object that wraps a FrozenCircuit. When
 applied as part of a larger circuit, a CircuitOperation will execute all
 component operations in order, including any nested CircuitOperations.
 """
+
+from __future__ import annotations
+
 import math
 from functools import cached_property
 from typing import (
@@ -81,16 +84,16 @@ class CircuitOperation(ops.Operation):
 
     def __init__(
         self,
-        circuit: 'cirq.FrozenCircuit',
+        circuit: cirq.FrozenCircuit,
         repetitions: INT_TYPE = 1,
-        qubit_map: Optional[Dict['cirq.Qid', 'cirq.Qid']] = None,
+        qubit_map: Optional[Dict[cirq.Qid, cirq.Qid]] = None,
         measurement_key_map: Optional[Dict[str, str]] = None,
         param_resolver: Optional[study.ParamResolverOrSimilarType] = None,
         repetition_ids: Optional[Sequence[str]] = None,
         parent_path: Tuple[str, ...] = (),
-        extern_keys: FrozenSet['cirq.MeasurementKey'] = frozenset(),
+        extern_keys: FrozenSet[cirq.MeasurementKey] = frozenset(),
         use_repetition_ids: Optional[bool] = None,
-        repeat_until: Optional['cirq.Condition'] = None,
+        repeat_until: Optional[cirq.Condition] = None,
     ):
         """Initializes a CircuitOperation.
 
@@ -214,7 +217,7 @@ class CircuitOperation(ops.Operation):
                 raise ValueError('Infinite loop: condition is not modified in subcircuit.')
 
     @property
-    def circuit(self) -> 'cirq.FrozenCircuit':
+    def circuit(self) -> cirq.FrozenCircuit:
         return self._circuit
 
     @property
@@ -230,11 +233,11 @@ class CircuitOperation(ops.Operation):
         return self._use_repetition_ids
 
     @property
-    def repeat_until(self) -> Optional['cirq.Condition']:
+    def repeat_until(self) -> Optional[cirq.Condition]:
         return self._repeat_until
 
     @property
-    def qubit_map(self) -> Mapping['cirq.Qid', 'cirq.Qid']:
+    def qubit_map(self) -> Mapping[cirq.Qid, cirq.Qid]:
         return self._qubit_map
 
     @property
@@ -249,14 +252,14 @@ class CircuitOperation(ops.Operation):
     def parent_path(self) -> Tuple[str, ...]:
         return self._parent_path
 
-    def base_operation(self) -> 'cirq.CircuitOperation':
+    def base_operation(self) -> cirq.CircuitOperation:
         """Returns a copy of this operation with only the wrapped circuit.
 
         Key and qubit mappings, parameter values, and repetitions are not copied.
         """
         return CircuitOperation(self.circuit)
 
-    def replace(self, **changes) -> 'cirq.CircuitOperation':
+    def replace(self, **changes) -> cirq.CircuitOperation:
         """Returns a copy of this operation with the specified changes."""
         kwargs = {
             'circuit': self.circuit,
@@ -293,7 +296,7 @@ class CircuitOperation(ops.Operation):
     # Methods for getting post-mapping properties of the contained circuit.
 
     @property
-    def qubits(self) -> Tuple['cirq.Qid', ...]:
+    def qubits(self) -> Tuple[cirq.Qid, ...]:
         """Returns the qubits operated on by this object."""
         ordered_qubits = ops.QubitOrder.DEFAULT.order_for(self.circuit.all_qubits())
         return tuple(self.qubit_map.get(q, q) for q in ordered_qubits)
@@ -319,7 +322,7 @@ class CircuitOperation(ops.Operation):
             raise ValueError('Cannot unroll circuit due to nondeterministic repetitions')
 
     @cached_property
-    def _measurement_key_objs(self) -> FrozenSet['cirq.MeasurementKey']:
+    def _measurement_key_objs(self) -> FrozenSet[cirq.MeasurementKey]:
         circuit_keys = protocols.measurement_key_objs(self.circuit)
         if circuit_keys and self.use_repetition_ids:
             self._ensure_deterministic_loop_count()
@@ -337,14 +340,14 @@ class CircuitOperation(ops.Operation):
             for key in circuit_keys
         )
 
-    def _measurement_key_objs_(self) -> FrozenSet['cirq.MeasurementKey']:
+    def _measurement_key_objs_(self) -> FrozenSet[cirq.MeasurementKey]:
         return self._measurement_key_objs
 
     def _measurement_key_names_(self) -> FrozenSet[str]:
         return frozenset(str(key) for key in self._measurement_key_objs_())
 
     @cached_property
-    def _control_keys(self) -> FrozenSet['cirq.MeasurementKey']:
+    def _control_keys(self) -> FrozenSet[cirq.MeasurementKey]:
         keys = (
             frozenset()
             if not protocols.control_keys(self.circuit)
@@ -355,7 +358,7 @@ class CircuitOperation(ops.Operation):
             keys |= frozenset(mapped_repeat_until.keys) - self._measurement_key_objs_()
         return keys
 
-    def _control_keys_(self) -> FrozenSet['cirq.MeasurementKey']:
+    def _control_keys_(self) -> FrozenSet[cirq.MeasurementKey]:
         return self._control_keys
 
     def _is_parameterized_(self) -> bool:
@@ -370,7 +373,7 @@ class CircuitOperation(ops.Operation):
         yield from protocols.parameter_names(self._mapped_any_loop)
 
     @cached_property
-    def _mapped_any_loop(self) -> 'cirq.Circuit':
+    def _mapped_any_loop(self) -> cirq.Circuit:
         circuit = self.circuit.unfreeze()
         if self.qubit_map:
             circuit = circuit.transform_qubits(lambda q: self.qubit_map.get(q, q))
@@ -382,7 +385,7 @@ class CircuitOperation(ops.Operation):
             circuit = protocols.resolve_parameters(circuit, self.param_resolver, recursive=False)
         return circuit.unfreeze(copy=False)
 
-    def _mapped_single_loop(self, repetition_id: Optional[str] = None) -> 'cirq.Circuit':
+    def _mapped_single_loop(self, repetition_id: Optional[str] = None) -> cirq.Circuit:
         circuit = self._mapped_any_loop
         if repetition_id:
             circuit = protocols.with_rescoped_keys(circuit, (repetition_id,))
@@ -391,7 +394,7 @@ class CircuitOperation(ops.Operation):
         )
 
     @cached_property
-    def _mapped_repeat_until(self) -> Optional['cirq.Condition']:
+    def _mapped_repeat_until(self) -> Optional[cirq.Condition]:
         """Applies measurement_key_map, param_resolver, and current scope to repeat_until."""
         repeat_until = self.repeat_until
         if not repeat_until:
@@ -410,7 +413,7 @@ class CircuitOperation(ops.Operation):
             bindable_keys=self._extern_keys | self._measurement_key_objs,
         )
 
-    def mapped_circuit(self, deep: bool = False) -> 'cirq.Circuit':
+    def mapped_circuit(self, deep: bool = False) -> cirq.Circuit:
         """Applies all maps to the contained circuit and returns the result.
 
         Args:
@@ -438,14 +441,14 @@ class CircuitOperation(ops.Operation):
             )
         return circuit
 
-    def mapped_op(self, deep: bool = False) -> 'cirq.CircuitOperation':
+    def mapped_op(self, deep: bool = False) -> cirq.CircuitOperation:
         """As `mapped_circuit`, but wraps the result in a CircuitOperation."""
         return CircuitOperation(circuit=self.mapped_circuit(deep=deep).freeze())
 
-    def _decompose_(self) -> Iterator['cirq.Operation']:
+    def _decompose_(self) -> Iterator[cirq.Operation]:
         return self.mapped_circuit(deep=False).all_operations()
 
-    def _act_on_(self, sim_state: 'cirq.SimulationStateBase') -> bool:
+    def _act_on_(self, sim_state: cirq.SimulationStateBase) -> bool:
         mapped_repeat_until = self._mapped_repeat_until
         if mapped_repeat_until:
             circuit = self._mapped_single_loop()
@@ -593,7 +596,7 @@ class CircuitOperation(ops.Operation):
         repetitions: Optional[IntParam] = None,
         repetition_ids: Optional[Sequence[str]] = None,
         use_repetition_ids: Optional[bool] = None,
-    ) -> 'CircuitOperation':
+    ) -> CircuitOperation:
         """Returns a copy of this operation repeated 'repetitions' times.
          Each repetition instance will be identified by a single repetition_id.
 
@@ -656,7 +659,7 @@ class CircuitOperation(ops.Operation):
             use_repetition_ids=use_repetition_ids,
         )
 
-    def __pow__(self, power: IntParam) -> 'cirq.CircuitOperation':
+    def __pow__(self, power: IntParam) -> cirq.CircuitOperation:
         return self.repeat(power)
 
     def _with_key_path_(self, path: Tuple[str, ...]):
@@ -666,7 +669,7 @@ class CircuitOperation(ops.Operation):
         return self.replace(parent_path=prefix + self.parent_path)
 
     def _with_rescoped_keys_(
-        self, path: Tuple[str, ...], bindable_keys: FrozenSet['cirq.MeasurementKey']
+        self, path: Tuple[str, ...], bindable_keys: FrozenSet[cirq.MeasurementKey]
     ):
         # The following line prevents binding to measurement keys in previous repeated subcircuits
         # "just because their repetition ids matched". If we eventually decide to change that
@@ -690,7 +693,7 @@ class CircuitOperation(ops.Operation):
         """
         return self._with_key_path_(path)
 
-    def with_repetition_ids(self, repetition_ids: List[str]) -> 'cirq.CircuitOperation':
+    def with_repetition_ids(self, repetition_ids: List[str]) -> cirq.CircuitOperation:
         """Returns a copy of this `CircuitOperation` with the given repetition IDs.
 
         Args:
@@ -703,8 +706,8 @@ class CircuitOperation(ops.Operation):
         return self.replace(repetition_ids=repetition_ids)
 
     def with_qubit_mapping(
-        self, qubit_map: Union[Mapping['cirq.Qid', 'cirq.Qid'], Callable[['cirq.Qid'], 'cirq.Qid']]
-    ) -> 'cirq.CircuitOperation':
+        self, qubit_map: Union[Mapping[cirq.Qid, cirq.Qid], Callable[[cirq.Qid], cirq.Qid]]
+    ) -> cirq.CircuitOperation:
         """Returns a copy of this operation with an updated qubit mapping.
 
         Users should pass either 'qubit_map' or 'transform' to this method.
@@ -743,7 +746,7 @@ class CircuitOperation(ops.Operation):
             )
         return new_op
 
-    def with_qubits(self, *new_qubits: 'cirq.Qid') -> 'cirq.CircuitOperation':
+    def with_qubits(self, *new_qubits: cirq.Qid) -> cirq.CircuitOperation:
         """Returns a copy of this operation with an updated qubit mapping.
 
         Args:
@@ -763,7 +766,7 @@ class CircuitOperation(ops.Operation):
             raise ValueError(f'Expected {expected} qubits, got {len(new_qubits)}.')
         return self.with_qubit_mapping(dict(zip(self.qubits, new_qubits)))
 
-    def with_measurement_key_mapping(self, key_map: Mapping[str, str]) -> 'cirq.CircuitOperation':
+    def with_measurement_key_mapping(self, key_map: Mapping[str, str]) -> cirq.CircuitOperation:
         """Returns a copy of this operation with an updated key mapping.
 
         Args:
@@ -797,12 +800,12 @@ class CircuitOperation(ops.Operation):
             )
         return new_op
 
-    def _with_measurement_key_mapping_(self, key_map: Mapping[str, str]) -> 'cirq.CircuitOperation':
+    def _with_measurement_key_mapping_(self, key_map: Mapping[str, str]) -> cirq.CircuitOperation:
         return self.with_measurement_key_mapping(key_map)
 
     def with_params(
-        self, param_values: 'cirq.ParamResolverOrSimilarType', recursive: bool = False
-    ) -> 'cirq.CircuitOperation':
+        self, param_values: cirq.ParamResolverOrSimilarType, recursive: bool = False
+    ) -> cirq.CircuitOperation:
         """Returns a copy of this operation with an updated ParamResolver.
 
         Any existing parameter mappings will have their values updated given
@@ -838,8 +841,8 @@ class CircuitOperation(ops.Operation):
         return self.replace(param_resolver=new_params)
 
     def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'cirq.CircuitOperation':
+        self, resolver: cirq.ParamResolver, recursive: bool
+    ) -> cirq.CircuitOperation:
         resolved = self.with_params(resolver.param_dict, recursive)
         # repetitions can resolve to a float, but this is ok since constructor converts to
         # nearby int.

cirq/circuits/circuit_operation_test.py

@@ -168,7 +168,7 @@ def test_with_qubits():
 
     assert op_base.with_qubit_mapping({a: d, b: c, d: a}) == op_with_qubits
 
-    def map_fn(qubit: 'cirq.Qid') -> 'cirq.Qid':
+    def map_fn(qubit: cirq.Qid) -> cirq.Qid:
         if qubit == a:
             return d
         if qubit == b:

cirq/circuits/circuit_test.py

@@ -11,12 +11,13 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
 import itertools
 import os
 import time
 from collections import defaultdict
 from random import randint, random, randrange, sample
-from typing import Iterator, Optional, Tuple, TYPE_CHECKING
+from typing import Iterator, Optional, Tuple
 
 import numpy as np
 import pytest
@@ -49,9 +50,6 @@ BCONE = ValidatingTestDevice(
 )
 
 
-if TYPE_CHECKING:
-    import cirq
-
 q0, q1, q2, q3 = cirq.LineQubit.range(4)
 
 
@@ -893,8 +891,8 @@ def test_insert_at_frontier():
             self.replacer = replacer
 
         def optimization_at(
-            self, circuit: 'cirq.Circuit', index: int, op: 'cirq.Operation'
-        ) -> Optional['cirq.PointOptimizationSummary']:
+            self, circuit: cirq.Circuit, index: int, op: cirq.Operation
+        ) -> Optional[cirq.PointOptimizationSummary]:
             new_ops = self.replacer(op)
             return cirq.PointOptimizationSummary(
                 clear_span=1, clear_qubits=op.qubits, new_operations=new_ops

cirq/circuits/frozen_circuit.py

@@ -11,7 +11,11 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
 """An immutable version of the Circuit data structure."""
+
+from __future__ import annotations
+
 from functools import cached_property
 from types import NotImplementedType
 from typing import (
@@ -46,8 +50,8 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
 
     def __init__(
         self,
-        *contents: 'cirq.OP_TREE',
-        strategy: 'cirq.InsertStrategy' = InsertStrategy.EARLIEST,
+        *contents: cirq.OP_TREE,
+        strategy: cirq.InsertStrategy = InsertStrategy.EARLIEST,
         tags: Sequence[Hashable] = (),
     ) -> None:
         """Initializes a frozen circuit.
@@ -71,19 +75,19 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
         self._tags = tuple(tags)
 
     @classmethod
-    def _from_moments(cls, moments: Iterable['cirq.Moment']) -> 'FrozenCircuit':
+    def _from_moments(cls, moments: Iterable[cirq.Moment]) -> FrozenCircuit:
         new_circuit = FrozenCircuit()
         new_circuit._moments = tuple(moments)
         return new_circuit
 
     @property
-    def moments(self) -> Sequence['cirq.Moment']:
+    def moments(self) -> Sequence[cirq.Moment]:
         return self._moments
 
-    def freeze(self) -> 'cirq.FrozenCircuit':
+    def freeze(self) -> cirq.FrozenCircuit:
         return self
 
-    def unfreeze(self, copy: bool = True) -> 'cirq.Circuit':
+    def unfreeze(self, copy: bool = True) -> cirq.Circuit:
         return Circuit._from_moments(self._moments)
 
     @property
@@ -92,11 +96,11 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
         return self._tags
 
     @cached_property
-    def untagged(self) -> 'cirq.FrozenCircuit':
+    def untagged(self) -> cirq.FrozenCircuit:
         """Returns the underlying FrozenCircuit without any tags."""
         return self._from_moments(self._moments) if self.tags else self
 
-    def with_tags(self, *new_tags: Hashable) -> 'cirq.FrozenCircuit':
+    def with_tags(self, *new_tags: Hashable) -> cirq.FrozenCircuit:
         """Creates a new tagged `FrozenCircuit` with `self.tags` and `new_tags` combined."""
         if not new_tags:
             return self
@@ -146,28 +150,28 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
         return protocols.is_measurement(self.unfreeze())
 
     @_compat.cached_method
-    def all_qubits(self) -> FrozenSet['cirq.Qid']:
+    def all_qubits(self) -> FrozenSet[cirq.Qid]:
         return super().all_qubits()
 
     @cached_property
-    def _all_operations(self) -> Tuple['cirq.Operation', ...]:
+    def _all_operations(self) -> Tuple[cirq.Operation, ...]:
         return tuple(super().all_operations())
 
-    def all_operations(self) -> Iterator['cirq.Operation']:
+    def all_operations(self) -> Iterator[cirq.Operation]:
         return iter(self._all_operations)
 
     def has_measurements(self) -> bool:
         return self._is_measurement_()
 
     @_compat.cached_method
-    def all_measurement_key_objs(self) -> FrozenSet['cirq.MeasurementKey']:
+    def all_measurement_key_objs(self) -> FrozenSet[cirq.MeasurementKey]:
         return super().all_measurement_key_objs()
 
-    def _measurement_key_objs_(self) -> FrozenSet['cirq.MeasurementKey']:
+    def _measurement_key_objs_(self) -> FrozenSet[cirq.MeasurementKey]:
         return self.all_measurement_key_objs()
 
     @_compat.cached_method
-    def _control_keys_(self) -> FrozenSet['cirq.MeasurementKey']:
+    def _control_keys_(self) -> FrozenSet[cirq.MeasurementKey]:
         return super()._control_keys_()
 
     @_compat.cached_method
@@ -190,8 +194,8 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
         return super()._parameter_names_() | tag_params
 
     def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'cirq.FrozenCircuit':
+        self, resolver: cirq.ParamResolver, recursive: bool
+    ) -> cirq.FrozenCircuit:
         resolved_circuit = super()._resolve_parameters_(resolver, recursive)
         resolved_tags = [
             protocols.resolve_parameters(tag, resolver, recursive) for tag in self.tags
@@ -201,23 +205,23 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
     def _measurement_key_names_(self) -> FrozenSet[str]:
         return self.all_measurement_key_names()
 
-    def __add__(self, other) -> 'cirq.FrozenCircuit':
+    def __add__(self, other) -> cirq.FrozenCircuit:
         return (self.unfreeze() + other).freeze()
 
-    def __radd__(self, other) -> 'cirq.FrozenCircuit':
+    def __radd__(self, other) -> cirq.FrozenCircuit:
         return (other + self.unfreeze()).freeze()
 
     # Needed for numpy to handle multiplication by np.int64 correctly.
     __array_priority__ = 10000
 
     # TODO: handle multiplication / powers differently?
-    def __mul__(self, other) -> 'cirq.FrozenCircuit':
+    def __mul__(self, other) -> cirq.FrozenCircuit:
         return (self.unfreeze() * other).freeze()
 
-    def __rmul__(self, other) -> 'cirq.FrozenCircuit':
+    def __rmul__(self, other) -> cirq.FrozenCircuit:
         return (other * self.unfreeze()).freeze()
 
-    def __pow__(self, other) -> 'cirq.FrozenCircuit':
+    def __pow__(self, other) -> cirq.FrozenCircuit:
         try:
             return (self.unfreeze() ** other).freeze()
         except:
@@ -238,20 +242,20 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
         return cls(moments, strategy=InsertStrategy.EARLIEST, tags=tags)
 
     def concat_ragged(
-        *circuits: 'cirq.AbstractCircuit', align: Union['cirq.Alignment', str] = Alignment.LEFT
-    ) -> 'cirq.FrozenCircuit':
+        *circuits: cirq.AbstractCircuit, align: Union[cirq.Alignment, str] = Alignment.LEFT
+    ) -> cirq.FrozenCircuit:
         return AbstractCircuit.concat_ragged(*circuits, align=align).freeze()
 
     concat_ragged.__doc__ = AbstractCircuit.concat_ragged.__doc__
 
     def zip(
-        *circuits: 'cirq.AbstractCircuit', align: Union['cirq.Alignment', str] = Alignment.LEFT
-    ) -> 'cirq.FrozenCircuit':
+        *circuits: cirq.AbstractCircuit, align: Union[cirq.Alignment, str] = Alignment.LEFT
+    ) -> cirq.FrozenCircuit:
         return AbstractCircuit.zip(*circuits, align=align).freeze()
 
     zip.__doc__ = AbstractCircuit.zip.__doc__
 
-    def to_op(self) -> 'cirq.CircuitOperation':
+    def to_op(self) -> cirq.CircuitOperation:
         """Creates a CircuitOperation wrapping this circuit."""
         from cirq.circuits import CircuitOperation