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

cirq/value/linear_dict.py

@@ -14,6 +14,8 @@
 
 """Linear combination represented as mapping of things to coefficients."""
 
+from __future__ import annotations
+
 from typing import (
     AbstractSet,
     Any,
@@ -63,7 +65,7 @@ class _SympyPrinter(sympy.printing.str.StrPrinter):
         return super()._print(expr, **kwargs)
 
 
-def _format_coefficient(format_spec: str, coefficient: 'cirq.TParamValComplex') -> str:
+def _format_coefficient(format_spec: str, coefficient: cirq.TParamValComplex) -> str:
     if isinstance(coefficient, sympy.Basic):
         printer = _SympyPrinter(format_spec)
         return printer.doprint(coefficient)
@@ -83,7 +85,7 @@ def _format_coefficient(format_spec: str, coefficient: 'cirq.TParamValComplex')
     return f'({real_str}+{imag_str}j)'
 
 
-def _format_term(format_spec: str, vector: TVector, coefficient: 'cirq.TParamValComplex') -> str:
+def _format_term(format_spec: str, vector: TVector, coefficient: cirq.TParamValComplex) -> str:
     coefficient_str = _format_coefficient(format_spec, coefficient)
     if not coefficient_str:
         return coefficient_str
@@ -93,7 +95,7 @@ def _format_term(format_spec: str, vector: TVector, coefficient: 'cirq.TParamVal
     return '+' + result
 
 
-def _format_terms(terms: Iterable[Tuple[TVector, 'cirq.TParamValComplex']], format_spec: str):
+def _format_terms(terms: Iterable[Tuple[TVector, cirq.TParamValComplex]], format_spec: str):
     formatted_terms = [_format_term(format_spec, vector, coeff) for vector, coeff in terms]
     s = ''.join(formatted_terms)
     if not s:
@@ -120,7 +122,7 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComple
 
     def __init__(
         self,
-        terms: Optional[Mapping[TVector, 'cirq.TParamValComplex']] = None,
+        terms: Optional[Mapping[TVector, cirq.TParamValComplex]] = None,
         validator: Optional[Callable[[TVector], bool]] = None,
     ) -> None:
         """Initializes linear combination from a collection of terms.
@@ -136,7 +138,7 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComple
         """
         self._has_validator = validator is not None
         self._is_valid = validator or (lambda x: True)
-        self._terms: Dict[TVector, 'cirq.TParamValComplex'] = {}
+        self._terms: Dict[TVector, cirq.TParamValComplex] = {}
         if terms is not None:
             self.update(terms)
 
@@ -172,31 +174,31 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComple
         snapshot = self.copy().clean(atol=0)
         return snapshot._terms.keys()
 
-    def values(self) -> ValuesView['cirq.TParamValComplex']:
+    def values(self) -> ValuesView[cirq.TParamValComplex]:
         snapshot = self.copy().clean(atol=0)
         return snapshot._terms.values()
 
-    def items(self) -> ItemsView[TVector, 'cirq.TParamValComplex']:
+    def items(self) -> ItemsView[TVector, cirq.TParamValComplex]:
         snapshot = self.copy().clean(atol=0)
         return snapshot._terms.items()
 
     # pylint: disable=function-redefined
     @overload
     def update(
-        self, other: Mapping[TVector, 'cirq.TParamValComplex'], **kwargs: 'cirq.TParamValComplex'
+        self, other: Mapping[TVector, cirq.TParamValComplex], **kwargs: cirq.TParamValComplex
     ) -> None:
         pass
 
     @overload
     def update(
         self,
-        other: Iterable[Tuple[TVector, 'cirq.TParamValComplex']],
-        **kwargs: 'cirq.TParamValComplex',
+        other: Iterable[Tuple[TVector, cirq.TParamValComplex]],
+        **kwargs: cirq.TParamValComplex,
     ) -> None:
         pass
 
     @overload
-    def update(self, *args: Any, **kwargs: 'cirq.TParamValComplex') -> None:
+    def update(self, *args: Any, **kwargs: cirq.TParamValComplex) -> None:
         pass
 
     def update(self, *args, **kwargs):
@@ -211,11 +213,11 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComple
         self.clean(atol=0)
 
     @overload
-    def get(self, vector: TVector) -> 'cirq.TParamValComplex':
+    def get(self, vector: TVector) -> cirq.TParamValComplex:
         pass
 
     @overload
-    def get(self, vector: TVector, default: TDefault) -> Union['cirq.TParamValComplex', TDefault]:
+    def get(self, vector: TVector, default: TDefault) -> Union[cirq.TParamValComplex, TDefault]:
         pass
 
     def get(self, vector, default=0):
@@ -228,10 +230,10 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComple
     def __contains__(self, vector: Any) -> bool:
         return vector in self._terms and self._terms[vector] != 0
 
-    def __getitem__(self, vector: TVector) -> 'cirq.TParamValComplex':
+    def __getitem__(self, vector: TVector) -> cirq.TParamValComplex:
         return self._terms.get(vector, 0)
 
-    def __setitem__(self, vector: TVector, coefficient: 'cirq.TParamValComplex') -> None:
+    def __setitem__(self, vector: TVector, coefficient: cirq.TParamValComplex) -> None:
         self._check_vector_valid(vector)
         if coefficient != 0:
             self._terms[vector] = coefficient
@@ -279,21 +281,21 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComple
         factory = type(self)
         return factory({v: -c for v, c in self.items()})
 
-    def __imul__(self, a: 'cirq.TParamValComplex') -> Self:
+    def __imul__(self, a: cirq.TParamValComplex) -> Self:
         for vector in self:
             self._terms[vector] *= a
         self.clean(atol=0)
         return self
 
-    def __mul__(self, a: 'cirq.TParamValComplex') -> Self:
+    def __mul__(self, a: cirq.TParamValComplex) -> Self:
         result = self.copy()
         result *= a
         return result.copy()
 
-    def __rmul__(self, a: 'cirq.TParamValComplex') -> Self:
+    def __rmul__(self, a: cirq.TParamValComplex) -> Self:
         return self.__mul__(a)
 
-    def __truediv__(self, a: 'cirq.TParamValComplex') -> Self:
+    def __truediv__(self, a: cirq.TParamValComplex) -> Self:
         return self.__mul__(1 / a)
 
     def __bool__(self) -> bool:
@@ -370,7 +372,7 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComple
     def _parameter_names_(self) -> AbstractSet[str]:
         return set(name for v in self._terms.values() for name in protocols.parameter_names(v))
 
-    def _resolve_parameters_(self, resolver: 'cirq.ParamResolver', recursive: bool) -> 'LinearDict':
+    def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> LinearDict:
         result = self.copy()
         result.update(
             {

cirq/value/periodic_value.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 AbstractSet, Any, TYPE_CHECKING
 
 import sympy
@@ -35,7 +37,7 @@ class PeriodicValue:
     interval.
     """
 
-    def __init__(self, value: 'cirq.TParamVal', period: 'cirq.TParamVal'):
+    def __init__(self, value: cirq.TParamVal, period: cirq.TParamVal):
         """Initializes the equivalence class.
 
         Args:
@@ -99,9 +101,7 @@ class PeriodicValue:
 
         return parameter_names(self.value) | parameter_names(self.period)
 
-    def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'PeriodicValue':
+    def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> PeriodicValue:
         # HACK: Avoids circular dependencies.
         from cirq.protocols import resolve_parameters
 

cirq/value/probability.py

@@ -14,6 +14,8 @@
 
 """Utilities for handling probabilities."""
 
+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 
 import numpy as np
@@ -44,7 +46,7 @@ def validate_probability(p: float, p_str: str) -> float:
     return p
 
 
-def state_vector_to_probabilities(state_vector: 'cirq.STATE_VECTOR_LIKE') -> np.ndarray:
+def state_vector_to_probabilities(state_vector: cirq.STATE_VECTOR_LIKE) -> np.ndarray:
     """Function to transform a state vector like object into a numpy array of probabilities."""
     valid_state_vector = to_valid_state_vector(state_vector)
     return np.abs(valid_state_vector) ** 2

cirq/value/product_state.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
 from dataclasses import dataclass
 from typing import Dict, Iterator, Optional, Sequence, Tuple, TYPE_CHECKING
@@ -28,7 +30,7 @@ if TYPE_CHECKING:
 class _NamedOneQubitState(metaclass=abc.ABCMeta):
     """Abstract class representing a one-qubit state of note."""
 
-    def on(self, qubit: 'cirq.Qid') -> 'ProductState':
+    def on(self, qubit: cirq.Qid) -> ProductState:
         """Associates one qubit with this named state.
 
         The returned object is a ProductState of length 1.
@@ -57,7 +59,7 @@ class ProductState:
     with `cirq.KET_PLUS(q0)`.
     """
 
-    states: Dict['cirq.Qid', _NamedOneQubitState]
+    states: Dict[cirq.Qid, _NamedOneQubitState]
 
     def __init__(self, states=None):
         if states is None:
@@ -66,10 +68,10 @@ class ProductState:
         object.__setattr__(self, 'states', states)
 
     @property
-    def qubits(self) -> Sequence['cirq.Qid']:
+    def qubits(self) -> Sequence[cirq.Qid]:
         return sorted(self.states.keys())
 
-    def __mul__(self, other: 'cirq.ProductState') -> 'cirq.ProductState':
+    def __mul__(self, other: cirq.ProductState) -> cirq.ProductState:
         if not isinstance(other, ProductState):
             raise ValueError("Multiplication is only supported with other TensorProductStates.")
 
@@ -93,11 +95,11 @@ class ProductState:
         )
         return f'cirq.ProductState({{{states_dict_repr}}})'
 
-    def __getitem__(self, qubit: 'cirq.Qid') -> _NamedOneQubitState:
+    def __getitem__(self, qubit: cirq.Qid) -> _NamedOneQubitState:
         """Return the _NamedOneQubitState at the given qubit."""
         return self.states[qubit]
 
-    def __iter__(self) -> Iterator[Tuple['cirq.Qid', _NamedOneQubitState]]:
+    def __iter__(self) -> Iterator[Tuple[cirq.Qid, _NamedOneQubitState]]:
         yield from self.states.items()
 
     def __len__(self) -> int:
@@ -119,7 +121,7 @@ class ProductState:
     def _from_json_dict_(cls, states, **kwargs):
         return cls(states=dict(states))
 
-    def state_vector(self, qubit_order: Optional['cirq.QubitOrder'] = None) -> np.ndarray:
+    def state_vector(self, qubit_order: Optional[cirq.QubitOrder] = None) -> np.ndarray:
         """The state-vector representation of this state."""
         from cirq import ops
 
@@ -136,7 +138,7 @@ class ProductState:
 
         return mat
 
-    def projector(self, qubit_order: Optional['cirq.QubitOrder'] = None) -> np.ndarray:
+    def projector(self, qubit_order: Optional[cirq.QubitOrder] = None) -> np.ndarray:
         """The projector associated with this state expressed as a matrix.
 
         This is |s⟩⟨s| where |s⟩ is this state.
@@ -174,7 +176,7 @@ class _PauliEigenState(_NamedOneQubitState):
         return f'cirq.{self._symbol}.basis[{self.eigenvalue:+d}]'
 
     @abc.abstractmethod
-    def stabilized_by(self) -> Tuple[int, 'cirq.Pauli']:
+    def stabilized_by(self) -> Tuple[int, cirq.Pauli]:
         pass
 
     def __eq__(self, other) -> bool:
@@ -201,7 +203,7 @@ class _XEigenState(_PauliEigenState):
             return np.array([1, -1]) / np.sqrt(2)
         raise ValueError(f"Bad eigenvalue: {self.eigenvalue}")  # pragma: no cover
 
-    def stabilized_by(self) -> Tuple[int, 'cirq.Pauli']:
+    def stabilized_by(self) -> Tuple[int, cirq.Pauli]:
         # Prevent circular import from `value.value_equality`
         from cirq import ops
 
@@ -218,7 +220,7 @@ class _YEigenState(_PauliEigenState):
             return np.array([1, -1j]) / np.sqrt(2)
         raise ValueError(f"Bad eigenvalue: {self.eigenvalue}")  # pragma: no cover
 
-    def stabilized_by(self) -> Tuple[int, 'cirq.Pauli']:
+    def stabilized_by(self) -> Tuple[int, cirq.Pauli]:
         from cirq import ops
 
         return self.eigenvalue, ops.Y
@@ -234,7 +236,7 @@ class _ZEigenState(_PauliEigenState):
             return np.array([0, 1])
         raise ValueError(f"Bad eigenvalue: {self.eigenvalue}")  # pragma: no cover
 
-    def stabilized_by(self) -> Tuple[int, 'cirq.Pauli']:
+    def stabilized_by(self) -> Tuple[int, cirq.Pauli]:
         from cirq import ops
 
         return self.eigenvalue, ops.Z

cirq/work/collector.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
 from typing import Any, Iterator, List, Optional, Tuple, TYPE_CHECKING, Union
 
@@ -29,7 +31,7 @@ if TYPE_CHECKING:
 class CircuitSampleJob:
     """Describes a sampling task."""
 
-    def __init__(self, circuit: 'cirq.AbstractCircuit', *, repetitions: int, tag: Any = None):
+    def __init__(self, circuit: cirq.AbstractCircuit, *, repetitions: int, tag: Any = None):
         """Inits CircuitSampleJob.
 
         Args:
@@ -57,7 +59,7 @@ class CircuitSampleJob:
 
 
 class CircuitSampleJobTree(Protocol):
-    def __iter__(self) -> Iterator[Union[CircuitSampleJob, 'CircuitSampleJobTree']]:
+    def __iter__(self) -> Iterator[Union[CircuitSampleJob, CircuitSampleJobTree]]:
         pass
 
 
@@ -106,7 +108,7 @@ class Collector(metaclass=abc.ABCMeta):
 
     def collect(
         self,
-        sampler: 'cirq.Sampler',
+        sampler: cirq.Sampler,
         *,
         concurrency: int = 2,
         max_total_samples: Optional[int] = None,
@@ -141,7 +143,7 @@ class Collector(metaclass=abc.ABCMeta):
 
     async def collect_async(
         self,
-        sampler: 'cirq.Sampler',
+        sampler: cirq.Sampler,
         *,
         concurrency: int = 2,
         max_total_samples: Optional[int] = None,
@@ -167,7 +169,7 @@ class Collector(metaclass=abc.ABCMeta):
             The collector's result after all desired samples have been
             collected.
         """
-        results: duet.AsyncCollector[Tuple[CircuitSampleJob, 'cirq.Result']] = duet.AsyncCollector()
+        results: duet.AsyncCollector[Tuple[CircuitSampleJob, cirq.Result]] = duet.AsyncCollector()
         job_error = None
         running_jobs = 0
         queued_jobs: List[CircuitSampleJob] = []

cirq/work/observable_measurement.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
 import itertools
@@ -50,8 +52,8 @@ document(
 
 
 def _with_parameterized_layers(
-    circuit: 'cirq.AbstractCircuit', qubits: Sequence['cirq.Qid'], needs_init_layer: bool
-) -> 'cirq.Circuit':
+    circuit: cirq.AbstractCircuit, qubits: Sequence[cirq.Qid], needs_init_layer: bool
+) -> cirq.Circuit:
     """Return a copy of the input circuit with parameterized single-qubit rotations.
 
     These rotations flank the circuit: the initial two layers of X and Y gates
@@ -136,7 +138,7 @@ class RepetitionsStoppingCriteria(StoppingCriteria):
         return protocols.dataclass_json_dict(self)
 
 
-_OBS_TO_PARAM_VAL: Dict[Tuple['cirq.Pauli', bool], Tuple[float, float]] = {
+_OBS_TO_PARAM_VAL: Dict[Tuple[cirq.Pauli, bool], Tuple[float, float]] = {
     (ops.X, False): (0, -1 / 2),
     (ops.X, True): (0, +1 / 2),
     (ops.Y, False): (1 / 2, 0),
@@ -148,7 +150,7 @@ _OBS_TO_PARAM_VAL: Dict[Tuple['cirq.Pauli', bool], Tuple[float, float]] = {
 second element in the key is whether to measure in the positive or negative (flipped) basis
 for readout symmetrization."""
 
-_STATE_TO_PARAM_VAL: Dict['_NamedOneQubitState', Tuple[float, float]] = {
+_STATE_TO_PARAM_VAL: Dict[_NamedOneQubitState, Tuple[float, float]] = {
     value.KET_PLUS: (0, +1 / 2),
     value.KET_MINUS: (0, -1 / 2),
     value.KET_IMAG: (-1 / 2, 0),
@@ -162,7 +164,7 @@ _STATE_TO_PARAM_VAL: Dict['_NamedOneQubitState', Tuple[float, float]] = {
 def _get_params_for_setting(
     setting: InitObsSetting,
     flips: Iterable[bool],
-    qubits: Sequence['cirq.Qid'],
+    qubits: Sequence[cirq.Qid],
     needs_init_layer: bool,
 ) -> Dict[str, float]:
     """Return the parameter dictionary for the given setting.
@@ -204,9 +206,9 @@ def _get_params_for_setting(
 
 def _pad_setting(
     max_setting: InitObsSetting,
-    qubits: Sequence['cirq.Qid'],
+    qubits: Sequence[cirq.Qid],
     pad_init_state_with=value.KET_ZERO,
-    pad_obs_with: 'cirq.Gate' = ops.Z,
+    pad_obs_with: cirq.Gate = ops.Z,
 ) -> InitObsSetting:
     """Pad `max_setting`'s `init_state` and `observable` with `pad_xx_with` operations
     (defaults:  |0> and Z) so each max_setting has the same qubits. We need this
@@ -303,7 +305,7 @@ class _FlippyMeasSpec:
 
     meas_spec: _MeasurementSpec
     flips: np.ndarray
-    qubits: Sequence['cirq.Qid']
+    qubits: Sequence[cirq.Qid]
 
     def param_tuples(self, *, needs_init_layer=True):
         yield from _get_params_for_setting(
@@ -318,7 +320,7 @@ class _FlippyMeasSpec:
 def _subdivide_meas_specs(
     meas_specs: Iterable[_MeasurementSpec],
     repetitions: int,
-    qubits: Sequence['cirq.Qid'],
+    qubits: Sequence[cirq.Qid],
     readout_symmetrization: bool,
 ) -> Tuple[List[_FlippyMeasSpec], int]:
     """Split measurement specs into sub-jobs for readout symmetrization
@@ -468,13 +470,13 @@ def _needs_init_layer(grouped_settings: Dict[InitObsSetting, List[InitObsSetting
 
 
 def measure_grouped_settings(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     grouped_settings: Dict[InitObsSetting, List[InitObsSetting]],
-    sampler: 'cirq.Sampler',
+    sampler: cirq.Sampler,
     stopping_criteria: StoppingCriteria,
     *,
     readout_symmetrization: bool = False,
-    circuit_sweep: 'cirq.Sweepable' = None,
+    circuit_sweep: cirq.Sweepable = None,
     readout_calibrations: Optional[BitstringAccumulator] = None,
     checkpoint: CheckpointFileOptions = CheckpointFileOptions(),
 ) -> List[BitstringAccumulator]:
@@ -597,8 +599,8 @@ def _parse_grouper(grouper: Union[str, GROUPER_T] = group_settings_greedy) -> GR
 
 
 def _get_all_qubits(
-    circuit: 'cirq.AbstractCircuit', observables: Iterable['cirq.PauliString']
-) -> List['cirq.Qid']:
+    circuit: cirq.AbstractCircuit, observables: Iterable[cirq.PauliString]
+) -> List[cirq.Qid]:
     """Helper function for `measure_observables` to get all qubits from a circuit and a
     collection of observables."""
     qubit_set = set()
@@ -609,13 +611,13 @@ def _get_all_qubits(
 
 
 def measure_observables(
-    circuit: 'cirq.AbstractCircuit',
-    observables: Iterable['cirq.PauliString'],
-    sampler: Union['cirq.Simulator', 'cirq.Sampler'],
+    circuit: cirq.AbstractCircuit,
+    observables: Iterable[cirq.PauliString],
+    sampler: Union[cirq.Simulator, cirq.Sampler],
     stopping_criteria: StoppingCriteria,
     *,
     readout_symmetrization: bool = False,
-    circuit_sweep: Optional['cirq.Sweepable'] = None,
+    circuit_sweep: Optional[cirq.Sweepable] = None,
     grouper: Union[str, GROUPER_T] = group_settings_greedy,
     readout_calibrations: Optional[BitstringAccumulator] = None,
     checkpoint: CheckpointFileOptions = CheckpointFileOptions(),
@@ -671,13 +673,13 @@ def measure_observables(
 
 
 def measure_observables_df(
-    circuit: 'cirq.AbstractCircuit',
-    observables: Iterable['cirq.PauliString'],
-    sampler: Union['cirq.Simulator', 'cirq.Sampler'],
+    circuit: cirq.AbstractCircuit,
+    observables: Iterable[cirq.PauliString],
+    sampler: Union[cirq.Simulator, cirq.Sampler],
     stopping_criteria: StoppingCriteria,
     *,
     readout_symmetrization: bool = False,
-    circuit_sweep: Optional['cirq.Sweepable'] = None,
+    circuit_sweep: Optional[cirq.Sweepable] = None,
     grouper: Union[str, GROUPER_T] = group_settings_greedy,
     readout_calibrations: Optional[BitstringAccumulator] = None,
     checkpoint: CheckpointFileOptions = CheckpointFileOptions(),

cirq/work/observable_measurement_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 dataclasses
 import datetime
 from typing import Any, Dict, Iterable, List, Mapping, Optional, Tuple, TYPE_CHECKING, Union
@@ -33,7 +35,7 @@ if TYPE_CHECKING:
     import cirq
 
 
-def _check_and_get_real_coef(observable: 'cirq.PauliString', atol: float):
+def _check_and_get_real_coef(observable: cirq.PauliString, atol: float):
     """Assert that a PauliString has a real coefficient and return it."""
     coef = observable.coefficient
     if isinstance(coef, sympy.Expr) or not np.isclose(coef.imag, 0, atol=atol):
@@ -43,8 +45,8 @@ def _check_and_get_real_coef(observable: 'cirq.PauliString', atol: float):
 
 def _obs_vals_from_measurements(
     bitstrings: np.ndarray,
-    qubit_to_index: Dict['cirq.Qid', int],
-    observable: 'cirq.PauliString',
+    qubit_to_index: Dict[cirq.Qid, int],
+    observable: cirq.PauliString,
     atol: float,
 ):
     """Multiply together bitstrings to get observed values of operators."""
@@ -61,8 +63,8 @@ def _obs_vals_from_measurements(
 
 def _stats_from_measurements(
     bitstrings: np.ndarray,
-    qubit_to_index: Dict['cirq.Qid', int],
-    observable: 'cirq.PauliString',
+    qubit_to_index: Dict[cirq.Qid, int],
+    observable: cirq.PauliString,
     atol: float,
 ) -> Tuple[float, float]:
     """Return the mean and squared standard error of the mean for the given
@@ -214,11 +216,11 @@ class BitstringAccumulator:
         self,
         meas_spec: _MeasurementSpec,
         simul_settings: List[InitObsSetting],
-        qubit_to_index: Dict['cirq.Qid', int],
+        qubit_to_index: Dict[cirq.Qid, int],
         bitstrings: Optional[np.ndarray] = None,
         chunksizes: Optional[np.ndarray] = None,
         timestamps: Optional[np.ndarray] = None,
-        readout_calibration: Optional['BitstringAccumulator'] = None,
+        readout_calibration: Optional[BitstringAccumulator] = None,
     ):
         self._meas_spec = meas_spec
         self._simul_settings = simul_settings

cirq/work/observable_readout_calibration.py

@@ -1,4 +1,7 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
+
+from __future__ import annotations
+
 import dataclasses
 from typing import Iterable, TYPE_CHECKING, Union
 
@@ -12,7 +15,7 @@ if TYPE_CHECKING:
 
 def calibrate_readout_error(
     qubits: Iterable[ops.Qid],
-    sampler: Union['cirq.Simulator', 'cirq.Sampler'],
+    sampler: Union[cirq.Simulator, cirq.Sampler],
     stopping_criteria: StoppingCriteria,
 ):
     # We know there won't be any fancy sweeps or observables so we can

cirq/work/observable_readout_calibration_test.py

@@ -1,4 +1,7 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
+
+from __future__ import annotations
+
 from typing import Sequence
 
 import numpy as np
@@ -19,7 +22,7 @@ class DepolarizingWithDampedReadoutNoiseModel(cirq.NoiseModel):
         self.readout_noise_gate = cirq.BitFlipChannel(bitflip_prob)
         self.readout_decay_gate = cirq.AmplitudeDampingChannel(decay_prob)
 
-    def noisy_moment(self, moment: 'cirq.Moment', system_qubits: Sequence['cirq.Qid']):
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
         if cirq.devices.noise_model.validate_all_measurements(moment):
             return [
                 cirq.Moment(self.readout_decay_gate(q) for q in system_qubits),

cirq/work/observable_settings.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import dataclasses
 import numbers
 from typing import (
@@ -123,13 +125,13 @@ def _max_weight_state(states: Iterable[value.ProductState]) -> Optional[value.Pr
     return value.ProductState(qubit_state_map)
 
 
-def zeros_state(qubits: Iterable['cirq.Qid']):
+def zeros_state(qubits: Iterable[cirq.Qid]):
     """Return the ProductState that is |00..00> on all qubits."""
     return value.ProductState({q: value.KET_ZERO for q in qubits})
 
 
 def observables_to_settings(
-    observables: Iterable['cirq.PauliString'], qubits: Iterable['cirq.Qid']
+    observables: Iterable[cirq.PauliString], qubits: Iterable[cirq.Qid]
 ) -> Iterable[InitObsSetting]:
     """Transform an observable to an InitObsSetting initialized in the
     all-zeros state.

cirq/work/pauli_sum_collector.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import collections
 from typing import cast, Dict, Optional, TYPE_CHECKING, Union
 
@@ -29,8 +31,8 @@ class PauliSumCollector(collector.Collector):
 
     def __init__(
         self,
-        circuit: 'cirq.AbstractCircuit',
-        observable: 'cirq.PauliSumLike',
+        circuit: cirq.AbstractCircuit,
+        observable: cirq.PauliSumLike,
         *,
         samples_per_term: int,
         max_samples_per_job: int = 1000000,
@@ -63,7 +65,7 @@ class PauliSumCollector(collector.Collector):
         self._samples_per_term = samples_per_term
         self._total_samples_requested = 0
 
-    def next_job(self) -> Optional['cirq.CircuitSampleJob']:
+    def next_job(self) -> Optional[cirq.CircuitSampleJob]:
         i = self._total_samples_requested // self._samples_per_term
         if i >= len(self._pauli_coef_terms):
             return None
@@ -77,7 +79,7 @@ class PauliSumCollector(collector.Collector):
             tag=pauli,
         )
 
-    def on_job_result(self, job: 'cirq.CircuitSampleJob', result: 'cirq.Result'):
+    def on_job_result(self, job: cirq.CircuitSampleJob, result: cirq.Result):
         job_id = cast(ops.PauliString, job.tag)
         parities = result.histogram(key='out', fold_func=lambda bits: np.sum(bits) % 2)
         self._zeros[job_id] += parities[0]
@@ -99,8 +101,8 @@ class PauliSumCollector(collector.Collector):
 
 
 def _circuit_plus_pauli_string_measurements(
-    circuit: 'cirq.AbstractCircuit', pauli_string: 'cirq.PauliString'
-) -> 'cirq.AbstractCircuit':
+    circuit: cirq.AbstractCircuit, pauli_string: cirq.PauliString
+) -> cirq.AbstractCircuit:
     """A circuit measuring the given observable at the end of the given circuit."""
     assert pauli_string
     return circuit.from_moments(

{cirq_core-1.6.0.dev20250501173104.dist-info → cirq_core-1.6.0.dev20250501231232.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cirq-core
-Version: 1.6.0.dev20250501173104
+Version: 1.6.0.dev20250501231232
 Summary: A framework for creating, editing, and invoking Noisy Intermediate Scale Quantum (NISQ) circuits.
 Home-page: http://github.com/quantumlib/cirq
 Author: The Cirq Developers