cirq-core 1.6.0.dev20250501173104__py3-none-any.whl → 1.6.0.dev20250501231232__py3-none-any.whl

cirq/transformers/transformer_api.py

@@ -14,6 +14,8 @@
 
 """Defines the API for circuit transformers in Cirq."""
 
+from __future__ import annotations
+
 import dataclasses
 import enum
 import functools
@@ -83,8 +85,8 @@ class _LoggerNode:
 
     transformer_id: int
     transformer_name: str
-    initial_circuit: 'cirq.AbstractCircuit'
-    final_circuit: 'cirq.AbstractCircuit'
+    initial_circuit: cirq.AbstractCircuit
+    final_circuit: cirq.AbstractCircuit
     logs: List[Tuple[LogLevel, Tuple[str, ...]]] = dataclasses.field(default_factory=list)
     nested_loggers: List[int] = dataclasses.field(default_factory=list)
 
@@ -116,7 +118,7 @@ class TransformerLogger:
         self._logs: List[_LoggerNode] = []
         self._stack: List[int] = []
 
-    def register_initial(self, circuit: 'cirq.AbstractCircuit', transformer_name: str) -> None:
+    def register_initial(self, circuit: cirq.AbstractCircuit, transformer_name: str) -> None:
         """Register the beginning of a new transformer stage.
 
         Args:
@@ -143,7 +145,7 @@ class TransformerLogger:
             raise ValueError('No active transformer found.')
         self._logs[self._stack[-1]].logs.append((level, args))
 
-    def register_final(self, circuit: 'cirq.AbstractCircuit', transformer_name: str) -> None:
+    def register_final(self, circuit: cirq.AbstractCircuit, transformer_name: str) -> None:
         """Register the end of the currently active transformer stage.
 
         Args:
@@ -195,13 +197,13 @@ class TransformerLogger:
 class NoOpTransformerLogger(TransformerLogger):
     """All calls to this logger are a no-op"""
 
-    def register_initial(self, circuit: 'cirq.AbstractCircuit', transformer_name: str) -> None:
+    def register_initial(self, circuit: cirq.AbstractCircuit, transformer_name: str) -> None:
         pass
 
     def log(self, *args: str, level: LogLevel = LogLevel.INFO) -> None:
         pass
 
-    def register_final(self, circuit: 'cirq.AbstractCircuit', transformer_name: str) -> None:
+    def register_final(self, circuit: cirq.AbstractCircuit, transformer_name: str) -> None:
         pass
 
     def show(self, level: LogLevel = LogLevel.INFO) -> None:
@@ -262,8 +264,8 @@ class TRANSFORMER(Protocol):
     """
 
     def __call__(
-        self, circuit: 'cirq.AbstractCircuit', *, context: Optional[TransformerContext] = None
-    ) -> 'cirq.AbstractCircuit': ...
+        self, circuit: cirq.AbstractCircuit, *, context: Optional[TransformerContext] = None
+    ) -> cirq.AbstractCircuit: ...
 
 
 _TRANSFORMER_T = TypeVar('_TRANSFORMER_T', bound=TRANSFORMER)
@@ -357,8 +359,8 @@ def transformer(cls_or_func: Any = None, *, add_deep_support: bool = False) -> A
 
         @functools.wraps(method)
         def method_with_logging(
-            self, circuit: 'cirq.AbstractCircuit', **kwargs
-        ) -> 'cirq.AbstractCircuit':
+            self, circuit: cirq.AbstractCircuit, **kwargs
+        ) -> cirq.AbstractCircuit:
             return _transform_and_log(
                 add_deep_support,
                 lambda circuit, **kwargs: method(self, circuit, **kwargs),
@@ -376,7 +378,7 @@ def transformer(cls_or_func: Any = None, *, add_deep_support: bool = False) -> A
         default_context = _get_default_context(func)
 
         @functools.wraps(func)
-        def func_with_logging(circuit: 'cirq.AbstractCircuit', **kwargs) -> 'cirq.AbstractCircuit':
+        def func_with_logging(circuit: cirq.AbstractCircuit, **kwargs) -> cirq.AbstractCircuit:
             return _transform_and_log(
                 add_deep_support,
                 func,
@@ -401,10 +403,10 @@ def _get_default_context(func: TRANSFORMER) -> TransformerContext:
 def _run_transformer_on_circuit(
     add_deep_support: bool,
     func: TRANSFORMER,
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     extracted_context: Optional[TransformerContext],
     **kwargs,
-) -> 'cirq.AbstractCircuit':
+) -> cirq.AbstractCircuit:
     mutable_circuit = None
     if extracted_context and extracted_context.deep and add_deep_support:
         batch_replace = []
@@ -429,10 +431,10 @@ def _transform_and_log(
     add_deep_support: bool,
     func: TRANSFORMER,
     transformer_name: str,
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     extracted_context: Optional[TransformerContext],
     **kwargs,
-) -> 'cirq.AbstractCircuit':
+) -> cirq.AbstractCircuit:
     """Helper to log initial and final circuits before and after calling the transformer."""
     if extracted_context:
         extracted_context.logger.register_initial(circuit, transformer_name)

cirq/transformers/transformer_primitives.py

@@ -14,6 +14,8 @@
 
 """Defines primitives for common transformer patterns."""
 
+from __future__ import annotations
+
 import bisect
 import dataclasses
 from collections import defaultdict
@@ -157,7 +159,7 @@ def _map_operations_impl(
     """
     tags_to_ignore_set = set(tags_to_ignore)
 
-    def apply_map_func(op: 'cirq.Operation', idx: int) -> List['cirq.Operation']:
+    def apply_map_func(op: cirq.Operation, idx: int) -> List[cirq.Operation]:
         if tags_to_ignore_set.intersection(op.tags):
             return [op]
         if deep and isinstance(op.untagged, circuits.CircuitOperation):
@@ -173,7 +175,7 @@ def _map_operations_impl(
             ).with_tags(*op.tags)
         mapped_ops = [*ops.flatten_to_ops(map_func(op, idx))]
         op_qubits = set(op.qubits)
-        mapped_ops_qubits: Set['cirq.Qid'] = set()
+        mapped_ops_qubits: Set[cirq.Qid] = set()
         has_overlapping_ops = False
         for mapped_op in mapped_ops:
             if raise_if_add_qubits and not op_qubits.issuperset(mapped_op.qubits):
@@ -194,9 +196,9 @@ def _map_operations_impl(
             ]
         return mapped_ops
 
-    new_moments: List[List['cirq.Operation']] = []
+    new_moments: List[List[cirq.Operation]] = []
     for idx, moment in enumerate(circuit):
-        curr_moments: List[List['cirq.Operation']] = [[]] if wrap_in_circuit_op else []
+        curr_moments: List[List[cirq.Operation]] = [[]] if wrap_in_circuit_op else []
         placement_cache = circuits.circuit._PlacementCache()
         for op in moment:
             mapped_ops = apply_map_func(op, idx)
@@ -305,21 +307,21 @@ class _MergedCircuit:
             of a set to store operations to preserve insertion order.
     """
 
-    qubit_indexes: Dict['cirq.Qid', List[int]] = dataclasses.field(
+    qubit_indexes: Dict[cirq.Qid, List[int]] = dataclasses.field(
         default_factory=lambda: defaultdict(lambda: [-1])
     )
-    mkey_indexes: Dict['cirq.MeasurementKey', List[int]] = dataclasses.field(
+    mkey_indexes: Dict[cirq.MeasurementKey, List[int]] = dataclasses.field(
         default_factory=lambda: defaultdict(lambda: [-1])
     )
-    ckey_indexes: Dict['cirq.MeasurementKey', List[int]] = dataclasses.field(
+    ckey_indexes: Dict[cirq.MeasurementKey, List[int]] = dataclasses.field(
         default_factory=lambda: defaultdict(lambda: [-1])
     )
-    ops_by_index: List[Dict['cirq.Operation', int]] = dataclasses.field(default_factory=list)
+    ops_by_index: List[Dict[cirq.Operation, int]] = dataclasses.field(default_factory=list)
 
     def append_empty_moment(self) -> None:
         self.ops_by_index.append({})
 
-    def add_op_to_moment(self, moment_index: int, op: 'cirq.Operation') -> None:
+    def add_op_to_moment(self, moment_index: int, op: cirq.Operation) -> None:
         self.ops_by_index[moment_index][op] = 0
         for q in op.qubits:
             if moment_index > self.qubit_indexes[q][-1]:
@@ -331,7 +333,7 @@ class _MergedCircuit:
         for ckey in protocols.control_keys(op):
             bisect.insort(self.ckey_indexes[ckey], moment_index)
 
-    def remove_op_from_moment(self, moment_index: int, op: 'cirq.Operation') -> None:
+    def remove_op_from_moment(self, moment_index: int, op: cirq.Operation) -> None:
         self.ops_by_index[moment_index].pop(op)
         for q in op.qubits:
             if self.qubit_indexes[q][-1] == moment_index:
@@ -344,8 +346,8 @@ class _MergedCircuit:
             self.ckey_indexes[ckey].remove(moment_index)
 
     def get_mergeable_ops(
-        self, op: 'cirq.Operation', op_qs: Set['cirq.Qid']
-    ) -> Tuple[int, List['cirq.Operation']]:
+        self, op: cirq.Operation, op_qs: Set[cirq.Qid]
+    ) -> Tuple[int, List[cirq.Operation]]:
         # Find the index of previous moment which can be merged with `op`.
         idx = max([self.qubit_indexes[q][-1] for q in op_qs], default=-1)
         idx = max([idx] + [self.mkey_indexes[ckey][-1] for ckey in protocols.control_keys(op)])
@@ -360,7 +362,7 @@ class _MergedCircuit:
             left_op for left_op in self.ops_by_index[idx] if not op_qs.isdisjoint(left_op.qubits)
         ]
 
-    def get_cirq_circuit(self) -> 'cirq.Circuit':
+    def get_cirq_circuit(self) -> cirq.Circuit:
         return circuits.Circuit(circuits.Moment(m.keys()) for m in self.ops_by_index)
 
 
@@ -493,7 +495,7 @@ def merge_operations(
 
 def merge_operations_to_circuit_op(
     circuit: CIRCUIT_TYPE,
-    can_merge: Callable[[Sequence['cirq.Operation'], Sequence['cirq.Operation']], bool],
+    can_merge: Callable[[Sequence[cirq.Operation], Sequence[cirq.Operation]], bool],
     *,
     tags_to_ignore: Sequence[Hashable] = (),
     merged_circuit_op_tag: str = "Merged connected component",
@@ -524,8 +526,8 @@ def merge_operations_to_circuit_op(
         Copy of input circuit with valid connected components wrapped in tagged circuit operations.
     """
 
-    def merge_func(op1: 'cirq.Operation', op2: 'cirq.Operation') -> Optional['cirq.Operation']:
-        def get_ops(op: 'cirq.Operation'):
+    def merge_func(op1: cirq.Operation, op2: cirq.Operation) -> Optional[cirq.Operation]:
+        def get_ops(op: cirq.Operation):
             op_untagged = op.untagged
             return (
                 [*op_untagged.circuit.all_operations()]
@@ -573,7 +575,7 @@ def merge_k_qubit_unitaries_to_circuit_op(
         Copy of input circuit with valid connected components wrapped in tagged circuit operations.
     """
 
-    def can_merge(ops1: Sequence['cirq.Operation'], ops2: Sequence['cirq.Operation']) -> bool:
+    def can_merge(ops1: Sequence[cirq.Operation], ops2: Sequence[cirq.Operation]) -> bool:
         return all(
             protocols.num_qubits(op) <= k and protocols.has_unitary(op)
             for op_list in [ops1, ops2]
@@ -659,7 +661,7 @@ def unroll_circuit_op(
     """
 
     def map_func(m: circuits.Moment, _: int):
-        to_zip: List['cirq.AbstractCircuit'] = []
+        to_zip: List[cirq.AbstractCircuit] = []
         for op in m:
             op_untagged = op.untagged
             if isinstance(op_untagged, circuits.CircuitOperation):
@@ -751,7 +753,7 @@ def unroll_circuit_op_greedy_frontier(
         Copy of input circuit with (Tagged) CircuitOperation's expanded inline at qubit frontier.
     """
     unrolled_circuit = circuit.unfreeze(copy=True)
-    frontier: Dict['cirq.Qid', int] = defaultdict(lambda: 0)
+    frontier: Dict[cirq.Qid, int] = defaultdict(lambda: 0)
     idx = 0
     while idx < len(unrolled_circuit):
         for op in unrolled_circuit[idx].operations:
@@ -799,7 +801,7 @@ def toggle_tags(circuit: CIRCUIT_TYPE, tags: Sequence[Hashable], *, deep: bool =
     """
     tags_to_xor = set(tags)
 
-    def map_func(op: 'cirq.Operation', _) -> 'cirq.Operation':
+    def map_func(op: cirq.Operation, _) -> cirq.Operation:
         return (
             op
             if deep and isinstance(op, circuits.CircuitOperation)

cirq/transformers/transformer_primitives_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import Iterator, List, Optional
 
 import pytest
@@ -721,7 +723,7 @@ def test_merge_operations_to_circuit_op_merges_connected_component():
 ''',
     )
 
-    def can_merge(ops1: List['cirq.Operation'], ops2: List['cirq.Operation']) -> bool:
+    def can_merge(ops1: List[cirq.Operation], ops2: List[cirq.Operation]) -> bool:
         """Artificial example where a CZ will absorb any merge-able operation."""
         return any(o.gate == cirq.CZ for op_list in [ops1, ops2] for o in op_list)
 

cirq/value/classical_data.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import abc
 import enum
 from typing import Dict, List, Mapping, Optional, Sequence, Tuple, TYPE_CHECKING
@@ -45,21 +47,21 @@ class MeasurementType(enum.IntEnum):
 
 class ClassicalDataStoreReader(abc.ABC):
     @abc.abstractmethod
-    def keys(self) -> Tuple['cirq.MeasurementKey', ...]:
+    def keys(self) -> Tuple[cirq.MeasurementKey, ...]:
         """Gets the measurement keys in the order they were stored."""
 
     @property
     @abc.abstractmethod
-    def records(self) -> Mapping['cirq.MeasurementKey', List[Tuple[int, ...]]]:
+    def records(self) -> Mapping[cirq.MeasurementKey, List[Tuple[int, ...]]]:
         """Gets the a mapping from measurement key to measurement records."""
 
     @property
     @abc.abstractmethod
-    def channel_records(self) -> Mapping['cirq.MeasurementKey', List[int]]:
+    def channel_records(self) -> Mapping[cirq.MeasurementKey, List[int]]:
         """Gets the a mapping from measurement key to channel measurement records."""
 
     @abc.abstractmethod
-    def get_int(self, key: 'cirq.MeasurementKey', index=-1) -> int:
+    def get_int(self, key: cirq.MeasurementKey, index=-1) -> int:
         """Gets the integer corresponding to the measurement.
 
         The integer is determined by summing the qubit-dimensional basis value
@@ -81,7 +83,7 @@ class ClassicalDataStoreReader(abc.ABC):
         """
 
     @abc.abstractmethod
-    def get_digits(self, key: 'cirq.MeasurementKey', index=-1) -> Tuple[int, ...]:
+    def get_digits(self, key: cirq.MeasurementKey, index=-1) -> Tuple[int, ...]:
         """Gets the values of the qubits that were measured into this key.
 
         For example, if the measurement of qubits [q0, q1] produces [0, 1],
@@ -107,7 +109,7 @@ class ClassicalDataStoreReader(abc.ABC):
 class ClassicalDataStore(ClassicalDataStoreReader, abc.ABC):
     @abc.abstractmethod
     def record_measurement(
-        self, key: 'cirq.MeasurementKey', measurement: Sequence[int], qubits: Sequence['cirq.Qid']
+        self, key: cirq.MeasurementKey, measurement: Sequence[int], qubits: Sequence[cirq.Qid]
     ):
         """Records a measurement.
 
@@ -122,7 +124,7 @@ class ClassicalDataStore(ClassicalDataStoreReader, abc.ABC):
         """
 
     @abc.abstractmethod
-    def record_channel_measurement(self, key: 'cirq.MeasurementKey', measurement: int):
+    def record_channel_measurement(self, key: cirq.MeasurementKey, measurement: int):
         """Records a channel measurement.
 
         Args:
@@ -141,12 +143,10 @@ class ClassicalDataDictionaryStore(ClassicalDataStore):
     def __init__(
         self,
         *,
-        _records: Optional[Dict['cirq.MeasurementKey', List[Tuple[int, ...]]]] = None,
-        _measured_qubits: Optional[
-            Dict['cirq.MeasurementKey', List[Tuple['cirq.Qid', ...]]]
-        ] = None,
-        _channel_records: Optional[Dict['cirq.MeasurementKey', List[int]]] = None,
-        _measurement_types: Optional[Dict['cirq.MeasurementKey', 'cirq.MeasurementType']] = None,
+        _records: Optional[Dict[cirq.MeasurementKey, List[Tuple[int, ...]]]] = None,
+        _measured_qubits: Optional[Dict[cirq.MeasurementKey, List[Tuple[cirq.Qid, ...]]]] = None,
+        _channel_records: Optional[Dict[cirq.MeasurementKey, List[int]]] = None,
+        _measurement_types: Optional[Dict[cirq.MeasurementKey, cirq.MeasurementType]] = None,
     ):
         """Initializes a `ClassicalDataDictionaryStore` object."""
         if not _measurement_types:
@@ -165,40 +165,40 @@ class ClassicalDataDictionaryStore(ClassicalDataStore):
             _measured_qubits = {}
         if _channel_records is None:
             _channel_records = {}
-        self._records: Dict['cirq.MeasurementKey', List[Tuple[int, ...]]] = _records
-        self._measured_qubits: Dict['cirq.MeasurementKey', List[Tuple['cirq.Qid', ...]]] = (
+        self._records: Dict[cirq.MeasurementKey, List[Tuple[int, ...]]] = _records
+        self._measured_qubits: Dict[cirq.MeasurementKey, List[Tuple[cirq.Qid, ...]]] = (
             _measured_qubits
         )
-        self._channel_records: Dict['cirq.MeasurementKey', List[int]] = _channel_records
-        self._measurement_types: Dict['cirq.MeasurementKey', 'cirq.MeasurementType'] = (
+        self._channel_records: Dict[cirq.MeasurementKey, List[int]] = _channel_records
+        self._measurement_types: Dict[cirq.MeasurementKey, cirq.MeasurementType] = (
             _measurement_types
         )
 
     @property
-    def records(self) -> Mapping['cirq.MeasurementKey', List[Tuple[int, ...]]]:
+    def records(self) -> Mapping[cirq.MeasurementKey, List[Tuple[int, ...]]]:
         """Gets the a mapping from measurement key to measurement records."""
         return self._records
 
     @property
-    def channel_records(self) -> Mapping['cirq.MeasurementKey', List[int]]:
+    def channel_records(self) -> Mapping[cirq.MeasurementKey, List[int]]:
         """Gets the a mapping from measurement key to channel measurement records."""
         return self._channel_records
 
     @property
-    def measured_qubits(self) -> Mapping['cirq.MeasurementKey', List[Tuple['cirq.Qid', ...]]]:
+    def measured_qubits(self) -> Mapping[cirq.MeasurementKey, List[Tuple[cirq.Qid, ...]]]:
         """Gets the a mapping from measurement key to the qubits measured."""
         return self._measured_qubits
 
     @property
-    def measurement_types(self) -> Mapping['cirq.MeasurementKey', 'cirq.MeasurementType']:
+    def measurement_types(self) -> Mapping[cirq.MeasurementKey, cirq.MeasurementType]:
         """Gets the a mapping from measurement key to the measurement type."""
         return self._measurement_types
 
-    def keys(self) -> Tuple['cirq.MeasurementKey', ...]:
+    def keys(self) -> Tuple[cirq.MeasurementKey, ...]:
         return tuple(self._measurement_types.keys())
 
     def record_measurement(
-        self, key: 'cirq.MeasurementKey', measurement: Sequence[int], qubits: Sequence['cirq.Qid']
+        self, key: cirq.MeasurementKey, measurement: Sequence[int], qubits: Sequence[cirq.Qid]
     ):
         if len(measurement) != len(qubits):
             raise ValueError(f'{len(measurement)} measurements but {len(qubits)} qubits.')
@@ -217,7 +217,7 @@ class ClassicalDataDictionaryStore(ClassicalDataStore):
         measured_qubits.append(tuple(qubits))
         self._records[key].append(tuple(measurement))
 
-    def record_channel_measurement(self, key: 'cirq.MeasurementKey', measurement: int):
+    def record_channel_measurement(self, key: cirq.MeasurementKey, measurement: int):
         if key not in self._measurement_types:
             self._measurement_types[key] = MeasurementType.CHANNEL
             self._channel_records[key] = []
@@ -225,14 +225,14 @@ class ClassicalDataDictionaryStore(ClassicalDataStore):
             raise ValueError(f"Measurement already logged to key {key}")
         self._channel_records[key].append(measurement)
 
-    def get_digits(self, key: 'cirq.MeasurementKey', index=-1) -> Tuple[int, ...]:
+    def get_digits(self, key: cirq.MeasurementKey, index=-1) -> Tuple[int, ...]:
         return (
             self._records[key][index]
             if self._measurement_types[key] == MeasurementType.MEASUREMENT
             else (self._channel_records[key][index],)
         )
 
-    def get_int(self, key: 'cirq.MeasurementKey', index=-1) -> int:
+    def get_int(self, key: cirq.MeasurementKey, index=-1) -> int:
         if key not in self._measurement_types:
             raise KeyError(f'The measurement key {key} is not in {self._measurement_types}')
         measurement_type = self._measurement_types[key]

cirq/value/condition.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import abc
 import dataclasses
 from typing import Any, Dict, FrozenSet, Mapping, Optional, Tuple, TYPE_CHECKING
@@ -32,15 +34,15 @@ class Condition(abc.ABC):
 
     @property
     @abc.abstractmethod
-    def keys(self) -> Tuple['cirq.MeasurementKey', ...]:
+    def keys(self) -> Tuple[cirq.MeasurementKey, ...]:
         """Gets the control keys."""
 
     @abc.abstractmethod
-    def replace_key(self, current: 'cirq.MeasurementKey', replacement: 'cirq.MeasurementKey'):
+    def replace_key(self, current: cirq.MeasurementKey, replacement: cirq.MeasurementKey):
         """Replaces the control keys."""
 
     @abc.abstractmethod
-    def resolve(self, classical_data: 'cirq.ClassicalDataStoreReader') -> bool:
+    def resolve(self, classical_data: cirq.ClassicalDataStoreReader) -> bool:
         """Resolves the condition based on the measurements."""
 
     @property
@@ -48,24 +50,24 @@ class Condition(abc.ABC):
     def qasm(self):
         """Returns the qasm of this condition."""
 
-    def _qasm_(self, args: 'cirq.QasmArgs', **kwargs) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, **kwargs) -> Optional[str]:
         return self.qasm
 
-    def _with_measurement_key_mapping_(self, key_map: Mapping[str, str]) -> 'cirq.Condition':
+    def _with_measurement_key_mapping_(self, key_map: Mapping[str, str]) -> cirq.Condition:
         condition = self
         for k in self.keys:
             condition = condition.replace_key(k, mkp.with_measurement_key_mapping(k, key_map))
         return condition
 
-    def _with_key_path_prefix_(self, path: Tuple[str, ...]) -> 'cirq.Condition':
+    def _with_key_path_prefix_(self, path: Tuple[str, ...]) -> cirq.Condition:
         condition = self
         for k in self.keys:
             condition = condition.replace_key(k, mkp.with_key_path_prefix(k, path))
         return condition
 
     def _with_rescoped_keys_(
-        self, path: Tuple[str, ...], bindable_keys: FrozenSet['cirq.MeasurementKey']
-    ) -> 'cirq.Condition':
+        self, path: Tuple[str, ...], bindable_keys: FrozenSet[cirq.MeasurementKey]
+    ) -> cirq.Condition:
         condition = self
         for key in self.keys:
             for i in range(len(path) + 1):
@@ -85,14 +87,14 @@ class KeyCondition(Condition):
     time of resolution.
     """
 
-    key: 'cirq.MeasurementKey'
+    key: cirq.MeasurementKey
     index: int = -1
 
     @property
     def keys(self):
         return (self.key,)
 
-    def replace_key(self, current: 'cirq.MeasurementKey', replacement: 'cirq.MeasurementKey'):
+    def replace_key(self, current: cirq.MeasurementKey, replacement: cirq.MeasurementKey):
         return KeyCondition(replacement) if self.key == current else self
 
     def __str__(self):
@@ -103,7 +105,7 @@ class KeyCondition(Condition):
             return f'cirq.KeyCondition({self.key!r}, {self.index})'
         return f'cirq.KeyCondition({self.key!r})'
 
-    def resolve(self, classical_data: 'cirq.ClassicalDataStoreReader') -> bool:
+    def resolve(self, classical_data: cirq.ClassicalDataStoreReader) -> bool:
         if self.key not in classical_data.keys():
             raise ValueError(f'Measurement key {self.key} missing when testing classical control')
         return classical_data.get_int(self.key, self.index) != 0
@@ -119,7 +121,7 @@ class KeyCondition(Condition):
     def qasm(self):
         raise ValueError('QASM is defined only for SympyConditions of type key == constant.')
 
-    def _qasm_(self, args: 'cirq.QasmArgs', **kwargs) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, **kwargs) -> Optional[str]:
         args.validate_version('2.0', '3.0')
         key_str = str(self.key)
         if key_str not in args.meas_key_id_map:
@@ -162,7 +164,7 @@ class BitMaskKeyCondition(Condition):
         - bitmask: Optional bitmask to apply before doing the comparison.
     """
 
-    key: 'cirq.MeasurementKey' = attrs.field(
+    key: cirq.MeasurementKey = attrs.field(
         converter=lambda x: (
             x
             if isinstance(x, measurement_key.MeasurementKey)
@@ -180,8 +182,8 @@ class BitMaskKeyCondition(Condition):
 
     @staticmethod
     def create_equal_mask(
-        key: 'cirq.MeasurementKey', bitmask: int, *, index: int = -1
-    ) -> 'BitMaskKeyCondition':
+        key: cirq.MeasurementKey, bitmask: int, *, index: int = -1
+    ) -> BitMaskKeyCondition:
         """Creates a condition that evaluates (meas & bitmask) == bitmask."""
         return BitMaskKeyCondition(
             key, index, target_value=bitmask, equal_target=True, bitmask=bitmask
@@ -189,14 +191,14 @@ class BitMaskKeyCondition(Condition):
 
     @staticmethod
     def create_not_equal_mask(
-        key: 'cirq.MeasurementKey', bitmask: int, *, index: int = -1
-    ) -> 'BitMaskKeyCondition':
+        key: cirq.MeasurementKey, bitmask: int, *, index: int = -1
+    ) -> BitMaskKeyCondition:
         """Creates a condition that evaluates (meas & bitmask) != bitmask."""
         return BitMaskKeyCondition(
             key, index, target_value=bitmask, equal_target=False, bitmask=bitmask
         )
 
-    def replace_key(self, current: 'cirq.MeasurementKey', replacement: 'cirq.MeasurementKey'):
+    def replace_key(self, current: cirq.MeasurementKey, replacement: cirq.MeasurementKey):
         return BitMaskKeyCondition(replacement) if self.key == current else self
 
     def __str__(self):
@@ -218,7 +220,7 @@ class BitMaskKeyCondition(Condition):
         parameters = ', '.join(f'{f.name}={repr(values[f.name])}' for f in attrs.fields(type(self)))
         return f'cirq.BitMaskKeyCondition({parameters})'
 
-    def resolve(self, classical_data: 'cirq.ClassicalDataStoreReader') -> bool:
+    def resolve(self, classical_data: cirq.ClassicalDataStoreReader) -> bool:
         if self.key not in classical_data.keys():
             raise ValueError(f'Measurement key {self.key} missing when testing classical control')
         value = classical_data.get_int(self.key, self.index)
@@ -269,7 +271,7 @@ class SympyCondition(Condition):
             # keep the former here.
         )
 
-    def replace_key(self, current: 'cirq.MeasurementKey', replacement: 'cirq.MeasurementKey'):
+    def replace_key(self, current: cirq.MeasurementKey, replacement: cirq.MeasurementKey):
         return SympyCondition(self.expr.subs({str(current): sympy.Symbol(str(replacement))}))
 
     def __str__(self):
@@ -278,7 +280,7 @@ class SympyCondition(Condition):
     def __repr__(self):
         return f'cirq.SympyCondition({proper_repr(self.expr)})'
 
-    def resolve(self, classical_data: 'cirq.ClassicalDataStoreReader') -> bool:
+    def resolve(self, classical_data: cirq.ClassicalDataStoreReader) -> bool:
         missing = [str(k) for k in self.keys if k not in classical_data.keys()]
         if missing:
             raise ValueError(f'Measurement keys {missing} missing when testing classical control')

cirq/value/duration.py

@@ -11,8 +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.
+
 """A typed time delta that supports picosecond accuracy."""
 
+from __future__ import annotations
+
 import datetime
 from typing import AbstractSet, Any, Dict, List, Optional, Tuple, TYPE_CHECKING, Union
 
@@ -98,7 +101,7 @@ class Duration:
     def _parameter_names_(self) -> AbstractSet[str]:
         return protocols.parameter_names(self._time_vals)
 
-    def _resolve_parameters_(self, resolver: 'cirq.ParamResolver', recursive: bool) -> 'Duration':
+    def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> Duration:
         return _duration_from_time_vals(
             protocols.resolve_parameters(self._time_vals, resolver, recursive)
         )
@@ -121,16 +124,16 @@ class Duration:
         """Returns the number of milliseconds that the duration spans."""
         return self.total_picos() / 1000_000_000
 
-    def __add__(self, other) -> 'Duration':
+    def __add__(self, other) -> Duration:
         other = _attempt_duration_like_to_duration(other)
         if other is None:
             return NotImplemented
         return _duration_from_time_vals(_add_time_vals(self._time_vals, other._time_vals))
 
-    def __radd__(self, other) -> 'Duration':
+    def __radd__(self, other) -> Duration:
         return self.__add__(other)
 
-    def __sub__(self, other) -> 'Duration':
+    def __sub__(self, other) -> Duration:
         other = _attempt_duration_like_to_duration(other)
         if other is None:
             return NotImplemented
@@ -138,7 +141,7 @@ class Duration:
             _add_time_vals(self._time_vals, [-x for x in other._time_vals])
         )
 
-    def __rsub__(self, other) -> 'Duration':
+    def __rsub__(self, other) -> Duration:
         other = _attempt_duration_like_to_duration(other)
         if other is None:
             return NotImplemented
@@ -146,17 +149,17 @@ class Duration:
             _add_time_vals(other._time_vals, [-x for x in self._time_vals])
         )
 
-    def __mul__(self, other) -> 'Duration':
+    def __mul__(self, other) -> Duration:
         if not isinstance(other, (int, float, sympy.Expr)):
             return NotImplemented
         if other == 0:
             return _duration_from_time_vals([0] * 4)
         return _duration_from_time_vals([x * other for x in self._time_vals])
 
-    def __rmul__(self, other) -> 'Duration':
+    def __rmul__(self, other) -> Duration:
         return self.__mul__(other)
 
-    def __truediv__(self, other) -> Union['Duration', float]:
+    def __truediv__(self, other) -> Union[Duration, float]:
         if isinstance(other, (int, float, sympy.Expr)):
             new_time_vals = [x / other for x in self._time_vals]
             return _duration_from_time_vals(new_time_vals)