cirq-core 1.6.0.dev20250520054601__py3-none-any.whl → 1.6.0.dev20250520181654__py3-none-any.whl

cirq/value/linear_dict.py

@@ -20,7 +20,6 @@ from typing import (
     AbstractSet,
     Any,
     Callable,
-    Dict,
     Generic,
     ItemsView,
     Iterable,
@@ -28,12 +27,9 @@ from typing import (
     KeysView,
     Mapping,
     MutableMapping,
-    Optional,
     overload,
-    Tuple,
     TYPE_CHECKING,
     TypeVar,
-    Union,
     ValuesView,
 )
 
@@ -46,7 +42,7 @@ from cirq import protocols
 if TYPE_CHECKING:
     import cirq
 
-Scalar = Union[complex, np.number]
+Scalar = complex | np.number
 TVector = TypeVar('TVector')
 
 TDefault = TypeVar('TDefault')
@@ -95,7 +91,7 @@ def _format_term(format_spec: str, vector: TVector, coefficient: cirq.TParamValC
     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:
@@ -122,8 +118,8 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComple
 
     def __init__(
         self,
-        terms: Optional[Mapping[TVector, cirq.TParamValComplex]] = None,
-        validator: Optional[Callable[[TVector], bool]] = None,
+        terms: Mapping[TVector, cirq.TParamValComplex] | None = None,
+        validator: Callable[[TVector], bool] | None = None,
     ) -> None:
         """Initializes linear combination from a collection of terms.
 
@@ -138,7 +134,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)
 
@@ -192,7 +188,7 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComple
     @overload
     def update(
         self,
-        other: Iterable[Tuple[TVector, cirq.TParamValComplex]],
+        other: Iterable[tuple[TVector, cirq.TParamValComplex]],
         **kwargs: cirq.TParamValComplex,
     ) -> None:
         pass
@@ -217,7 +213,7 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComple
         pass
 
     @overload
-    def get(self, vector: TVector, default: TDefault) -> Union[cirq.TParamValComplex, TDefault]:
+    def get(self, vector: TVector, default: TDefault) -> cirq.TParamValComplex | TDefault:
         pass
 
     def get(self, vector, default=0):
@@ -354,7 +350,7 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComple
         else:
             p.text(str(self))
 
-    def _json_dict_(self) -> Dict[Any, Any]:
+    def _json_dict_(self) -> dict[Any, Any]:
         if self._has_validator:
             raise ValueError('LinearDict with a validator is not json serializable.')
         return {

cirq/value/measurement_key.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import Any, Dict, FrozenSet, Mapping, Optional, Tuple
+from typing import Any, Mapping
 
 MEASUREMENT_KEY_SEPARATOR = ':'
 
@@ -35,11 +35,11 @@ class MeasurementKey:
             appears first in the tuple.
     """
 
-    _hash: Optional[int] = dataclasses.field(default=None, init=False)
-    _str: Optional[str] = dataclasses.field(default=None, init=False)
+    _hash: int | None = dataclasses.field(default=None, init=False)
+    _str: str | None = dataclasses.field(default=None, init=False)
 
     name: str
-    path: Tuple[str, ...] = dataclasses.field(default_factory=tuple)
+    path: tuple[str, ...] = dataclasses.field(default_factory=tuple)
 
     def __post_init__(self):
         if not isinstance(self.name, str):
@@ -78,7 +78,7 @@ class MeasurementKey:
             object.__setattr__(self, '_hash', hash(str(self)))
         return self._hash
 
-    def __getstate__(self) -> Dict[str, Any]:
+    def __getstate__(self) -> dict[str, Any]:
         # clear cached hash value when pickling, see #6674
         state = self.__dict__
         if "_hash" in state:
@@ -112,10 +112,10 @@ class MeasurementKey:
         components = key_str.split(MEASUREMENT_KEY_SEPARATOR)
         return MeasurementKey(name=components[-1], path=tuple(components[:-1]))
 
-    def _with_key_path_(self, path: Tuple[str, ...]):
+    def _with_key_path_(self, path: tuple[str, ...]):
         return self.replace(path=path)
 
-    def _with_key_path_prefix_(self, prefix: Tuple[str, ...]):
+    def _with_key_path_prefix_(self, prefix: tuple[str, ...]):
         return self._with_key_path_(path=prefix + self.path)
 
     def with_key_path_prefix(self, *path_component: str):
@@ -126,7 +126,7 @@ class MeasurementKey:
         """
         return self.replace(path=path_component + self.path)
 
-    def _with_rescoped_keys_(self, path: Tuple[str, ...], bindable_keys: FrozenSet[MeasurementKey]):
+    def _with_rescoped_keys_(self, path: tuple[str, ...], bindable_keys: frozenset[MeasurementKey]):
         return self.replace(path=path + self.path)
 
     def _with_measurement_key_mapping_(self, key_map: Mapping[str, str]):

cirq/value/product_state.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import abc
 from dataclasses import dataclass
-from typing import Dict, Iterator, Optional, Sequence, Tuple, TYPE_CHECKING
+from typing import Iterator, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -59,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:
@@ -99,7 +99,7 @@ class ProductState:
         """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:
@@ -121,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: cirq.QubitOrder | None = None) -> np.ndarray:
         """The state-vector representation of this state."""
         from cirq import ops
 
@@ -138,7 +138,7 @@ class ProductState:
 
         return mat
 
-    def projector(self, qubit_order: Optional[cirq.QubitOrder] = None) -> np.ndarray:
+    def projector(self, qubit_order: cirq.QubitOrder | None = None) -> np.ndarray:
         """The projector associated with this state expressed as a matrix.
 
         This is |s⟩⟨s| where |s⟩ is this state.
@@ -176,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:
@@ -203,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
 
@@ -220,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
@@ -236,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/value/value_equality_attr.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Callable, Dict, Optional, overload, Union
+from typing import Any, Callable, overload
 
 from typing_extensions import Protocol
 
@@ -113,7 +113,7 @@ def _value_equality_approx_eq(
     )
 
 
-def _value_equality_getstate(self: _SupportsValueEquality) -> Dict[str, Any]:
+def _value_equality_getstate(self: _SupportsValueEquality) -> dict[str, Any]:
     # clear cached hash value when pickling, see #6674
     state = self.__dict__
     hash_attr = _compat._method_cache_name(self.__hash__)
@@ -148,13 +148,13 @@ def value_equality(
 
 
 def value_equality(
-    cls: Optional[type] = None,
+    cls: type | None = None,
     *,
     unhashable: bool = False,
     distinct_child_types: bool = False,
     manual_cls: bool = False,
     approximate: bool = False,
-) -> Union[Callable[[type], type], type]:
+) -> Callable[[type], type] | type:
     """Implements __eq__/__ne__/__hash__ via a _value_equality_values_ method.
 
     _value_equality_values_ is a method that the decorated class must implement.

cirq/vis/heatmap.py

@@ -16,19 +16,7 @@ from __future__ import annotations
 
 import copy
 from dataclasses import astuple, dataclass
-from typing import (
-    Any,
-    cast,
-    Dict,
-    List,
-    Mapping,
-    Optional,
-    overload,
-    Sequence,
-    SupportsFloat,
-    Tuple,
-    Union,
-)
+from typing import Any, cast, Mapping, overload, Sequence, SupportsFloat
 
 import matplotlib as mpl
 import matplotlib.collections as mpl_collections
@@ -39,9 +27,9 @@ from mpl_toolkits import axes_grid1
 from cirq.devices import grid_qubit
 from cirq.vis import vis_utils
 
-QubitTuple = Tuple[grid_qubit.GridQubit, ...]
+QubitTuple = tuple[grid_qubit.GridQubit, ...]
 
-Polygon = Sequence[Tuple[float, float]]
+Polygon = Sequence[tuple[float, float]]
 
 
 @dataclass
@@ -71,7 +59,7 @@ class PolygonUnit:
     polygon: Polygon
     value: float
     center: Point
-    annot: Optional[str]
+    annot: str | None
 
 
 class Heatmap:
@@ -88,9 +76,9 @@ class Heatmap:
 
     def __init__(
         self,
-        value_map: Union[
-            Mapping[QubitTuple, SupportsFloat], Mapping[grid_qubit.GridQubit, SupportsFloat]
-        ],
+        value_map: (
+            Mapping[QubitTuple, SupportsFloat] | Mapping[grid_qubit.GridQubit, SupportsFloat]
+        ),
         **kwargs,
     ):
         """2D qubit grid Heatmaps
@@ -131,7 +119,7 @@ class Heatmap:
         }
         self._validate_kwargs(kwargs)
         if '_config' not in self.__dict__:
-            self._config: Dict[str, Any] = {}
+            self._config: dict[str, Any] = {}
         self._config.update(
             {
                 "plot_colorbar": True,
@@ -144,7 +132,7 @@ class Heatmap:
         )
         self._config.update(kwargs)
 
-    def _extra_valid_kwargs(self) -> List[str]:
+    def _extra_valid_kwargs(self) -> list[str]:
         return []
 
     def _validate_kwargs(self, kwargs) -> None:
@@ -179,7 +167,7 @@ class Heatmap:
         self._config.update(kwargs)
         return self
 
-    def _qubits_to_polygon(self, qubits: QubitTuple) -> Tuple[Polygon, Point]:
+    def _qubits_to_polygon(self, qubits: QubitTuple) -> tuple[Polygon, Point]:
         qubit = qubits[0]
         x, y = float(qubit.row), float(qubit.col)
         return (
@@ -187,7 +175,7 @@ class Heatmap:
             Point(y, x),
         )
 
-    def _get_annotation_value(self, key, value) -> Optional[str]:
+    def _get_annotation_value(self, key, value) -> str | None:
         if self._config.get('annotation_map'):
             return self._config['annotation_map'].get(key)
         elif self._config.get('annotation_format'):
@@ -198,8 +186,8 @@ class Heatmap:
         else:
             return None
 
-    def _get_polygon_units(self) -> List[PolygonUnit]:
-        polygon_unit_list: List[PolygonUnit] = []
+    def _get_polygon_units(self) -> list[PolygonUnit]:
+        polygon_unit_list: list[PolygonUnit] = []
         for qubits, value in sorted(self._value_map.items()):
             polygon, center = self._qubits_to_polygon(qubits)
             polygon_unit_list.append(
@@ -231,7 +219,7 @@ class Heatmap:
 
     def _write_annotations(
         self,
-        centers_and_annot: List[Tuple[Point, Optional[str]]],
+        centers_and_annot: list[tuple[Point, str | None]],
         collection: mpl_collections.Collection,
         ax: plt.Axes,
     ) -> None:
@@ -245,7 +233,7 @@ class Heatmap:
             x, y = center
             face_luminance = vis_utils.relative_luminance(facecolor)
             text_color = 'black' if face_luminance > 0.4 else 'white'
-            text_kwargs: Dict[str, Any] = dict(color=text_color, ha="center", va="center")
+            text_kwargs: dict[str, Any] = dict(color=text_color, ha="center", va="center")
             text_kwargs.update(self._config.get('annotation_text_kwargs', {}))
             ax.text(x, y, annotation, **text_kwargs)
 
@@ -286,8 +274,8 @@ class Heatmap:
         return collection
 
     def plot(
-        self, ax: Optional[plt.Axes] = None, **kwargs: Any
-    ) -> Tuple[plt.Axes, mpl_collections.Collection]:
+        self, ax: plt.Axes | None = None, **kwargs: Any
+    ) -> tuple[plt.Axes, mpl_collections.Collection]:
         """Plots the heatmap on the given Axes.
         Args:
             ax: the Axes to plot on. If not given, a new figure is created,
@@ -358,13 +346,13 @@ class TwoQubitInteractionHeatmap(Heatmap):
                 coupler_margin: float, default = 0.03
                 coupler_width: float, default = 0.6
         """
-        self._config: Dict[str, Any] = {"coupler_margin": 0.03, "coupler_width": 0.6}
+        self._config: dict[str, Any] = {"coupler_margin": 0.03, "coupler_width": 0.6}
         super().__init__(value_map, **kwargs)
 
-    def _extra_valid_kwargs(self) -> List[str]:
+    def _extra_valid_kwargs(self) -> list[str]:
         return ["coupler_margin", "coupler_width"]
 
-    def _qubits_to_polygon(self, qubits: QubitTuple) -> Tuple[Polygon, Point]:
+    def _qubits_to_polygon(self, qubits: QubitTuple) -> tuple[Polygon, Point]:
         coupler_margin = self._config["coupler_margin"]
         coupler_width = self._config["coupler_width"]
         cwidth = coupler_width / 2.0
@@ -403,8 +391,8 @@ class TwoQubitInteractionHeatmap(Heatmap):
         return (polygon, Point((col1 + col2) / 2.0, (row1 + row2) / 2.0))
 
     def plot(
-        self, ax: Optional[plt.Axes] = None, **kwargs: Any
-    ) -> Tuple[plt.Axes, mpl_collections.Collection]:
+        self, ax: plt.Axes | None = None, **kwargs: Any
+    ) -> tuple[plt.Axes, mpl_collections.Collection]:
         """Plots the heatmap on the given Axes.
         Args:
             ax: the Axes to plot on. If not given, a new figure is created,
@@ -422,7 +410,7 @@ class TwoQubitInteractionHeatmap(Heatmap):
         original_config = copy.deepcopy(self._config)
         self.update_config(**kwargs)
         qubits = set([q for qubits in self._value_map.keys() for q in qubits])
-        collection_options: Dict[str, Any] = {"cmap": "binary"}
+        collection_options: dict[str, Any] = {"cmap": "binary"}
         highlighted_qubits = frozenset(kwargs.get("highlighted_qubits", ()))
         if not highlighted_qubits:
             collection_options.update(

cirq/work/collector.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import abc
-from typing import Any, Iterator, List, Optional, Tuple, TYPE_CHECKING, Union
+from typing import Any, Iterator, TYPE_CHECKING
 
 import duet
 import numpy as np
@@ -59,11 +59,11 @@ class CircuitSampleJob:
 
 
 class CircuitSampleJobTree(Protocol):
-    def __iter__(self) -> Iterator[Union[CircuitSampleJob, CircuitSampleJobTree]]:
+    def __iter__(self) -> Iterator[CircuitSampleJob | CircuitSampleJobTree]:
         pass
 
 
-CIRCUIT_SAMPLE_JOB_TREE = Union[CircuitSampleJob, CircuitSampleJobTree]
+CIRCUIT_SAMPLE_JOB_TREE = CircuitSampleJob | CircuitSampleJobTree
 
 
 class Collector(metaclass=abc.ABCMeta):
@@ -77,7 +77,7 @@ class Collector(metaclass=abc.ABCMeta):
     """
 
     @abc.abstractmethod
-    def next_job(self) -> Optional[CIRCUIT_SAMPLE_JOB_TREE]:
+    def next_job(self) -> CIRCUIT_SAMPLE_JOB_TREE | None:
         """Determines what to sample next.
 
         This method is called by driving code when more samples can be
@@ -107,11 +107,7 @@ class Collector(metaclass=abc.ABCMeta):
         """
 
     def collect(
-        self,
-        sampler: cirq.Sampler,
-        *,
-        concurrency: int = 2,
-        max_total_samples: Optional[int] = None,
+        self, sampler: cirq.Sampler, *, concurrency: int = 2, max_total_samples: int | None = None
     ) -> None:
         """Collects needed samples from a sampler.
 
@@ -142,11 +138,7 @@ class Collector(metaclass=abc.ABCMeta):
         )
 
     async def collect_async(
-        self,
-        sampler: cirq.Sampler,
-        *,
-        concurrency: int = 2,
-        max_total_samples: Optional[int] = None,
+        self, sampler: cirq.Sampler, *, concurrency: int = 2, max_total_samples: int | None = None
     ) -> None:
         """Asynchronously collects needed samples from a sampler.
 
@@ -169,10 +161,10 @@ 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] = []
+        queued_jobs: list[CircuitSampleJob] = []
         remaining_samples = np.inf if max_total_samples is None else max_total_samples
 
         async def run_job(job):
@@ -215,7 +207,7 @@ class Collector(metaclass=abc.ABCMeta):
                 self.on_job_result(job, result)
 
 
-def _flatten_jobs(tree: Optional[CIRCUIT_SAMPLE_JOB_TREE]) -> Iterator[CircuitSampleJob]:
+def _flatten_jobs(tree: CIRCUIT_SAMPLE_JOB_TREE | None) -> Iterator[CircuitSampleJob]:
     if isinstance(tree, CircuitSampleJob):
         yield tree
     elif tree is not None:

cirq/work/observable_grouping.py

@@ -14,20 +14,17 @@
 
 from __future__ import annotations
 
-from typing import Callable, cast, Dict, Iterable, List, TYPE_CHECKING
+from typing import Callable, cast, Iterable
 
 from cirq import ops, value
 from cirq.work.observable_settings import _max_weight_observable, _max_weight_state, InitObsSetting
 
-if TYPE_CHECKING:
-    pass
-
-GROUPER_T = Callable[[Iterable[InitObsSetting]], Dict[InitObsSetting, List[InitObsSetting]]]
+GROUPER_T = Callable[[Iterable[InitObsSetting]], dict[InitObsSetting, list[InitObsSetting]]]
 
 
 def group_settings_greedy(
     settings: Iterable[InitObsSetting],
-) -> Dict[InitObsSetting, List[InitObsSetting]]:
+) -> dict[InitObsSetting, list[InitObsSetting]]:
     """Greedily group settings which can be simultaneously measured.
 
     We construct a dictionary keyed by `max_setting` (see docstrings
@@ -48,7 +45,7 @@ def group_settings_greedy(
         input list of settings. Each dictionary value is a list of
         settings compatible with `max_setting`.
     """
-    grouped_settings: Dict[InitObsSetting, List[InitObsSetting]] = {}
+    grouped_settings: dict[InitObsSetting, list[InitObsSetting]] = {}
     for setting in settings:
         for max_setting, simul_settings in grouped_settings.items():
             trial_grouped_settings = simul_settings + [setting]