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

cirq/protocols/circuit_diagram_info_protocol.py

@@ -16,18 +16,7 @@ from __future__ import annotations
 
 import re
 from fractions import Fraction
-from typing import (
-    Any,
-    Dict,
-    Iterable,
-    List,
-    Optional,
-    overload,
-    Sequence,
-    TYPE_CHECKING,
-    TypeVar,
-    Union,
-)
+from typing import Any, Iterable, overload, Sequence, TYPE_CHECKING, TypeVar, Union
 
 import numpy as np
 import sympy
@@ -52,7 +41,7 @@ class CircuitDiagramInfo:
         wire_symbols: Iterable[str],
         exponent: Any = 1,
         connected: bool = True,
-        exponent_qubit_index: Optional[int] = None,
+        exponent_qubit_index: int | None = None,
         auto_exponent_parens: bool = True,
     ) -> None:
         """Inits CircuitDiagramInfo.
@@ -106,8 +95,8 @@ class CircuitDiagramInfo:
         )
 
     def _wire_symbols_including_formatted_exponent(
-        self, args: cirq.CircuitDiagramInfoArgs, *, preferred_exponent_index: Optional[int] = None
-    ) -> List[str]:
+        self, args: cirq.CircuitDiagramInfoArgs, *, preferred_exponent_index: int | None = None
+    ) -> list[str]:
         result = list(self.wire_symbols)
         exponent = self._formatted_exponent(args)
         if exponent is not None:
@@ -124,7 +113,7 @@ class CircuitDiagramInfo:
                 result[k] += f"^{exponent}"
         return result
 
-    def _formatted_exponent(self, args: cirq.CircuitDiagramInfoArgs) -> Optional[str]:
+    def _formatted_exponent(self, args: cirq.CircuitDiagramInfoArgs) -> str | None:
         if protocols.is_parameterized(self.exponent):
             name = str(self.exponent)
             return f'({name})' if _is_exposed_formula(name) else name
@@ -201,11 +190,11 @@ class CircuitDiagramInfoArgs:
 
     def __init__(
         self,
-        known_qubits: Optional[Iterable[cirq.Qid]],
-        known_qubit_count: Optional[int],
+        known_qubits: Iterable[cirq.Qid] | None,
+        known_qubit_count: int | None,
         use_unicode_characters: bool,
-        precision: Optional[int],
-        label_map: Optional[Dict[cirq.LabelEntity, int]],
+        precision: int | None,
+        label_map: dict[cirq.LabelEntity, int] | None,
         include_tags: bool = True,
         transpose: bool = False,
     ) -> None:
@@ -244,7 +233,7 @@ class CircuitDiagramInfoArgs:
             f'transpose={self.transpose!r})'
         )
 
-    def format_real(self, val: Union[sympy.Basic, int, float]) -> str:
+    def format_real(self, val: sympy.Basic | int | float) -> str:
         if isinstance(val, sympy.Basic):
             return str(val)
         if val == int(val):
@@ -253,7 +242,7 @@ class CircuitDiagramInfoArgs:
             return str(val)
         return f'{float(val):.{self.precision}}'
 
-    def format_complex(self, val: Union[sympy.Basic, int, float, cirq.TParamValComplex]) -> str:
+    def format_complex(self, val: sympy.Basic | int | float | cirq.TParamValComplex) -> str:
         if isinstance(val, sympy.Basic):
             return str(val)
         c = complex(val)
@@ -265,7 +254,7 @@ class CircuitDiagramInfoArgs:
         imag_str = '' if abs_imag == 1 else self.format_real(abs_imag)
         return f'{self.format_real(c.real)}{joiner}{imag_str}i'
 
-    def format_radians(self, radians: Union[sympy.Basic, int, float]) -> str:
+    def format_radians(self, radians: sympy.Basic | int | float) -> str:
         """Returns angle in radians as a human-readable string."""
         if protocols.is_parameterized(radians):
             return str(radians)
@@ -316,7 +305,7 @@ class SupportsCircuitDiagramInfo(Protocol):
     @doc_private
     def _circuit_diagram_info_(
         self, args: CircuitDiagramInfoArgs
-    ) -> Union[str, Iterable[str], CircuitDiagramInfo]:
+    ) -> str | Iterable[str] | CircuitDiagramInfo:
         """Describes how to draw an operation in a circuit diagram.
 
         This method is used by the global `cirq.diagram_info` method. If this
@@ -341,7 +330,7 @@ def _op_info_with_fallback(
     op: cirq.Operation, args: cirq.CircuitDiagramInfoArgs
 ) -> cirq.CircuitDiagramInfo:
     info = protocols.circuit_diagram_info(op, args, None)
-    rows: List[LabelEntity] = list(op.qubits)
+    rows: list[LabelEntity] = list(op.qubits)
     if args.label_map is not None:
         rows += protocols.measurement_keys_touched(op) & args.label_map.keys()
     if info is not None and info.wire_symbols:
@@ -371,25 +360,25 @@ def _op_info_with_fallback(
 # pylint: disable=function-redefined
 @overload
 def circuit_diagram_info(
-    val: Any, args: Optional[CircuitDiagramInfoArgs] = None
+    val: Any, args: CircuitDiagramInfoArgs | None = None
 ) -> CircuitDiagramInfo:
     pass
 
 
 @overload
 def circuit_diagram_info(
-    val: Any, args: Optional[CircuitDiagramInfoArgs], default: TDefault
-) -> Union[CircuitDiagramInfo, TDefault]:
+    val: Any, args: CircuitDiagramInfoArgs | None, default: TDefault
+) -> CircuitDiagramInfo | TDefault:
     pass
 
 
 @overload
-def circuit_diagram_info(val: Any, *, default: TDefault) -> Union[CircuitDiagramInfo, TDefault]:
+def circuit_diagram_info(val: Any, *, default: TDefault) -> CircuitDiagramInfo | TDefault:
     pass
 
 
 def circuit_diagram_info(
-    val: Any, args: Optional[CircuitDiagramInfoArgs] = None, default=RaiseTypeErrorIfNotProvided
+    val: Any, args: CircuitDiagramInfoArgs | None = None, default=RaiseTypeErrorIfNotProvided
 ):
     """Requests information on drawing an operation in a circuit diagram.
 

cirq/protocols/decompose_protocol.py

@@ -22,14 +22,10 @@ from types import NotImplementedType
 from typing import (
     Any,
     Callable,
-    Dict,
     Iterable,
     Iterator,
-    List,
-    Optional,
     overload,
     Sequence,
-    Tuple,
     TYPE_CHECKING,
     TypeVar,
     Union,
@@ -58,11 +54,11 @@ _CONTEXT_COUNTER = itertools.count()  # Use _reset_context_counter() to reset th
 @runtime_checkable
 class OpDecomposerWithContext(Protocol):
     def __call__(
-        self, __op: cirq.Operation, *, context: Optional[cirq.DecompositionContext] = None
+        self, __op: cirq.Operation, *, context: cirq.DecompositionContext | None = None
     ) -> DecomposeResult: ...
 
 
-OpDecomposer = Union[Callable[['cirq.Operation'], DecomposeResult], OpDecomposerWithContext]
+OpDecomposer = Callable[['cirq.Operation'], DecomposeResult] | OpDecomposerWithContext
 
 DECOMPOSE_TARGET_GATESET = ops.Gateset(
     ops.XPowGate,
@@ -130,7 +126,7 @@ class SupportsDecompose(Protocol):
         pass
 
     def _decompose_with_context_(
-        self, *, context: Optional[DecompositionContext] = None
+        self, *, context: DecompositionContext | None = None
     ) -> DecomposeResult:
         pass
 
@@ -154,17 +150,17 @@ class SupportsDecomposeWithQubits(Protocol):
     implements `SupportsDecomposeWithQubits`.
     """
 
-    def _decompose_(self, qubits: Tuple[cirq.Qid, ...]) -> DecomposeResult:
+    def _decompose_(self, qubits: tuple[cirq.Qid, ...]) -> DecomposeResult:
         pass
 
     def _decompose_with_context_(
-        self, qubits: Tuple[cirq.Qid, ...], *, context: Optional[DecompositionContext] = None
+        self, qubits: tuple[cirq.Qid, ...], *, context: DecompositionContext | None = None
     ) -> DecomposeResult:
         pass
 
 
 def _try_op_decomposer(
-    val: Any, decomposer: Optional[OpDecomposer], *, context: Optional[DecompositionContext] = None
+    val: Any, decomposer: OpDecomposer | None, *, context: DecompositionContext | None = None
 ) -> DecomposeResult:
     if decomposer is None or not isinstance(val, ops.Operation):
         return None
@@ -177,11 +173,11 @@ def _try_op_decomposer(
 
 @dataclasses.dataclass(frozen=True)
 class _DecomposeArgs:
-    context: Optional[DecompositionContext]
-    intercepting_decomposer: Optional[OpDecomposer]
-    fallback_decomposer: Optional[OpDecomposer]
-    keep: Optional[Callable[[cirq.Operation], bool]]
-    on_stuck_raise: Union[None, Exception, Callable[[cirq.Operation], Optional[Exception]]]
+    context: DecompositionContext | None
+    intercepting_decomposer: OpDecomposer | None
+    fallback_decomposer: OpDecomposer | None
+    keep: Callable[[cirq.Operation], bool] | None
+    on_stuck_raise: None | Exception | Callable[[cirq.Operation], Exception | None]
     preserve_structure: bool
 
 
@@ -227,15 +223,15 @@ def _decompose_dfs(item: Any, args: _DecomposeArgs) -> Iterator[cirq.Operation]:
 def decompose(
     val: Any,
     *,
-    intercepting_decomposer: Optional[OpDecomposer] = None,
-    fallback_decomposer: Optional[OpDecomposer] = None,
-    keep: Optional[Callable[[cirq.Operation], bool]] = None,
-    on_stuck_raise: Union[
-        None, Exception, Callable[[cirq.Operation], Optional[Exception]]
-    ] = _value_error_describing_bad_operation,
+    intercepting_decomposer: OpDecomposer | None = None,
+    fallback_decomposer: OpDecomposer | None = None,
+    keep: Callable[[cirq.Operation], bool] | None = None,
+    on_stuck_raise: (
+        None | Exception | Callable[[cirq.Operation], Exception | None]
+    ) = _value_error_describing_bad_operation,
     preserve_structure: bool = False,
-    context: Optional[DecompositionContext] = None,
-) -> List[cirq.Operation]:
+    context: DecompositionContext | None = None,
+) -> list[cirq.Operation]:
     """Recursively decomposes a value into `cirq.Operation`s meeting a criteria.
 
     Args:
@@ -316,14 +312,14 @@ def decompose(
 
 
 @overload
-def decompose_once(val: Any, **kwargs) -> List[cirq.Operation]:
+def decompose_once(val: Any, **kwargs) -> list[cirq.Operation]:
     pass
 
 
 @overload
 def decompose_once(
     val: Any, default: TDefault, *args, flatten: bool = True, **kwargs
-) -> Union[TDefault, List[cirq.Operation]]:
+) -> TDefault | list[cirq.Operation]:
     pass
 
 
@@ -332,7 +328,7 @@ def decompose_once(
     default=RaiseTypeErrorIfNotProvided,
     *args,
     flatten: bool = True,
-    context: Optional[DecompositionContext] = None,
+    context: DecompositionContext | None = None,
     **kwargs,
 ):
     """Decomposes a value into operations, if possible.
@@ -400,8 +396,8 @@ def decompose_once_with_qubits(
     qubits: Iterable[cirq.Qid],
     *,
     flatten: bool = True,
-    context: Optional[DecompositionContext] = None,
-) -> List[cirq.Operation]:
+    context: DecompositionContext | None = None,
+) -> list[cirq.Operation]:
     pass
 
 
@@ -409,11 +405,11 @@ def decompose_once_with_qubits(
 def decompose_once_with_qubits(
     val: Any,
     qubits: Iterable[cirq.Qid],
-    default: Optional[TDefault],
+    default: TDefault | None,
     *,
     flatten: bool = True,
-    context: Optional[DecompositionContext] = None,
-) -> Union[TDefault, List[cirq.Operation]]:
+    context: DecompositionContext | None = None,
+) -> TDefault | list[cirq.Operation]:
     pass
 
 
@@ -422,7 +418,7 @@ def decompose_once_with_qubits(
     qubits: Iterable[cirq.Qid],
     default=RaiseTypeErrorIfNotProvided,
     flatten: bool = True,
-    context: Optional[DecompositionContext] = None,
+    context: DecompositionContext | None = None,
 ):
     """Decomposes a value into operations on the given qubits.
 
@@ -461,7 +457,7 @@ def decompose_once_with_qubits(
 
 def _try_decompose_into_operations_and_qubits(
     val: Any,
-) -> Tuple[Optional[List[cirq.Operation]], Sequence[cirq.Qid], Tuple[int, ...]]:
+) -> tuple[list[cirq.Operation] | None, Sequence[cirq.Qid], tuple[int, ...]]:
     """Returns the value's decomposition (if any) and the qubits it applies to."""
 
     if isinstance(val, ops.Gate):
@@ -477,7 +473,7 @@ def _try_decompose_into_operations_and_qubits(
     result = decompose_once(val, None)
     if result is not None:
         qubit_set = set()
-        qid_shape_dict: Dict[cirq.Qid, int] = defaultdict(lambda: 1)
+        qid_shape_dict: dict[cirq.Qid, int] = defaultdict(lambda: 1)
         for op in result:
             for level, q in zip(qid_shape_protocol.qid_shape(op), op.qubits):
                 qubit_set.add(q)

cirq/protocols/inverse_protocol.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Iterable, List, overload, Tuple, TYPE_CHECKING, TypeVar, Union
+from typing import Any, Iterable, overload, TYPE_CHECKING, TypeVar
 
 from cirq import ops
 
@@ -23,7 +23,7 @@ if TYPE_CHECKING:
 
 # This is a special indicator value used by the inverse method to determine
 # whether or not the caller provided a 'default' argument.
-RaiseTypeErrorIfNotProvided: Tuple[List[Any]] = ([],)
+RaiseTypeErrorIfNotProvided: tuple[list[Any]] = ([],)
 
 TDefault = TypeVar('TDefault')
 
@@ -50,22 +50,22 @@ def inverse(val: cirq.OP_TREE) -> cirq.OP_TREE:
 
 
 @overload
-def inverse(val: cirq.Gate, default: TDefault) -> Union[TDefault, cirq.Gate]:
+def inverse(val: cirq.Gate, default: TDefault) -> TDefault | cirq.Gate:
     pass
 
 
 @overload
-def inverse(val: cirq.Operation, default: TDefault) -> Union[TDefault, cirq.Operation]:
+def inverse(val: cirq.Operation, default: TDefault) -> TDefault | cirq.Operation:
     pass
 
 
 @overload
-def inverse(val: cirq.Circuit, default: TDefault) -> Union[TDefault, cirq.Circuit]:
+def inverse(val: cirq.Circuit, default: TDefault) -> TDefault | cirq.Circuit:
     pass
 
 
 @overload
-def inverse(val: cirq.OP_TREE, default: TDefault) -> Union[TDefault, cirq.OP_TREE]:
+def inverse(val: cirq.OP_TREE, default: TDefault) -> TDefault | cirq.OP_TREE:
     pass
 
 
@@ -108,7 +108,7 @@ def inverse(val: Any, default: Any = RaiseTypeErrorIfNotProvided) -> Any:
     # Maybe it's an iterable of invertible items?
     # Note: we avoid str because 'a'[0] == 'a', which creates an infinite loop.
     if isinstance(val, Iterable) and not isinstance(val, (str, ops.Operation)):
-        unique_indicator: List[Any] = []
+        unique_indicator: list[Any] = []
         results = tuple(inverse(e, unique_indicator) for e in val)
         if all(e is not unique_indicator for e in results):
             return results[::-1]

cirq/protocols/json_serialization.py

@@ -21,21 +21,7 @@ import json
 import numbers
 import pathlib
 from types import NotImplementedType
-from typing import (
-    Any,
-    Callable,
-    cast,
-    Dict,
-    IO,
-    Iterable,
-    List,
-    Optional,
-    overload,
-    Sequence,
-    Tuple,
-    Type,
-    Union,
-)
+from typing import Any, Callable, cast, IO, Iterable, overload, Sequence
 
 import attrs
 import numpy as np
@@ -45,16 +31,16 @@ from typing_extensions import Protocol
 
 from cirq._doc import doc_private
 
-ObjectFactory = Union[Type, Callable[..., Any]]
+ObjectFactory = type | Callable[..., Any]
 
 
 class JsonResolver(Protocol):
     """Protocol for json resolver functions passed to read_json."""
 
-    def __call__(self, cirq_type: str) -> Optional[ObjectFactory]: ...
+    def __call__(self, cirq_type: str) -> ObjectFactory | None: ...
 
 
-def _lazy_resolver(dict_factory: Callable[[], Dict[str, ObjectFactory]]) -> JsonResolver:
+def _lazy_resolver(dict_factory: Callable[[], dict[str, ObjectFactory]]) -> JsonResolver:
     """A lazy JsonResolver based on a dict_factory.
 
     It only calls dict_factory when the first key is accessed.
@@ -64,13 +50,13 @@ def _lazy_resolver(dict_factory: Callable[[], Dict[str, ObjectFactory]]) -> Json
           class resolution map - it is assumed to be cached
     """
 
-    def json_resolver(cirq_type: str) -> Optional[ObjectFactory]:
+    def json_resolver(cirq_type: str) -> ObjectFactory | None:
         return dict_factory().get(cirq_type, None)
 
     return json_resolver
 
 
-DEFAULT_RESOLVERS: List[JsonResolver] = []
+DEFAULT_RESOLVERS: list[JsonResolver] = []
 """A default list of 'JsonResolver' functions for use in read_json.
 
 For more information about cirq_type resolution during deserialization
@@ -90,7 +76,7 @@ prepended to this list:
 """
 
 
-def _register_resolver(dict_factory: Callable[[], Dict[str, ObjectFactory]]) -> None:
+def _register_resolver(dict_factory: Callable[[], dict[str, ObjectFactory]]) -> None:
     """Register a resolver based on a dict factory for lazy initialization.
 
     Cirq modules are the ones referred in cirq/__init__.py. If a Cirq module
@@ -127,7 +113,7 @@ class SupportsJSON(Protocol):
     """
 
     @doc_private
-    def _json_dict_(self) -> Union[None, NotImplementedType, Dict[Any, Any]]:
+    def _json_dict_(self) -> None | NotImplementedType | dict[Any, Any]:
         pass
 
 
@@ -148,7 +134,7 @@ class HasJSONNamespace(Protocol):
         pass
 
 
-def obj_to_dict_helper(obj: Any, attribute_names: Iterable[str]) -> Dict[str, Any]:
+def obj_to_dict_helper(obj: Any, attribute_names: Iterable[str]) -> dict[str, Any]:
     """Construct a dictionary containing attributes from obj
 
     This is useful as a helper function in objects implementing the
@@ -170,7 +156,7 @@ def obj_to_dict_helper(obj: Any, attribute_names: Iterable[str]) -> Dict[str, An
 
 
 # pylint: enable=redefined-builtin
-def dataclass_json_dict(obj: Any) -> Dict[str, Any]:
+def dataclass_json_dict(obj: Any) -> dict[str, Any]:
     """Return a dictionary suitable for `_json_dict_` from a dataclass.
 
     Dataclasses keep track of their relevant fields, so we can automatically generate these.
@@ -186,7 +172,7 @@ def dataclass_json_dict(obj: Any) -> Dict[str, Any]:
     return obj_to_dict_helper(obj, attribute_names)
 
 
-def attrs_json_dict(obj: Any) -> Dict[str, Any]:
+def attrs_json_dict(obj: Any) -> dict[str, Any]:
     """Return a dictionary suitable for `_json_dict_` from an attrs dataclass."""
     attribute_names = [f.name for f in attrs.fields(type(obj))]
     return obj_to_dict_helper(obj, attribute_names)
@@ -339,8 +325,8 @@ class ObjectHook:
 
     def __init__(self, resolvers: Sequence[JsonResolver]) -> None:
         self.resolvers = resolvers
-        self.memo: Dict[int, SerializableByKey] = {}
-        self.context_map: Dict[int, SerializableByKey] = {}
+        self.memo: dict[int, SerializableByKey] = {}
+        self.context_map: dict[int, SerializableByKey] = {}
 
     def __call__(self, d):
         cirq_type = d.get('cirq_type')
@@ -383,7 +369,7 @@ class SerializableByKey(SupportsJSON):
     """
 
 
-def json_namespace(type_obj: Type) -> str:
+def json_namespace(type_obj: type) -> str:
     """Returns a namespace for JSON serialization of `type_obj`.
 
     Types can provide custom namespaces with `_json_namespace_`; otherwise, a
@@ -407,7 +393,7 @@ def json_namespace(type_obj: Type) -> str:
     raise ValueError(f'{type_obj} is not a Cirq type, and does not define _json_namespace_.')
 
 
-def json_cirq_type(type_obj: Type) -> str:
+def json_cirq_type(type_obj: type) -> str:
     """Returns a string type for JSON serialization of `type_obj`.
 
     This method is not part of the base serialization path. Together with
@@ -421,7 +407,7 @@ def json_cirq_type(type_obj: Type) -> str:
 
 
 def factory_from_json(
-    type_str: str, resolvers: Optional[Sequence[JsonResolver]] = None
+    type_str: str, resolvers: Sequence[JsonResolver] | None = None
 ) -> ObjectFactory:
     """Returns a factory for constructing objects of type `type_str`.
 
@@ -447,7 +433,7 @@ def factory_from_json(
     raise ValueError(f"Could not resolve type '{type_str}' during deserialization")
 
 
-def cirq_type_from_json(type_str: str, resolvers: Optional[Sequence[JsonResolver]] = None) -> Type:
+def cirq_type_from_json(type_str: str, resolvers: Sequence[JsonResolver] | None = None) -> type:
     """Returns a type object for JSON deserialization of `type_str`.
 
     This method is not part of the base deserialization path. Together with
@@ -477,12 +463,7 @@ def cirq_type_from_json(type_str: str, resolvers: Optional[Sequence[JsonResolver
 # pylint: disable=function-redefined
 @overload
 def to_json(
-    obj: Any,
-    file_or_fn: Union[IO, pathlib.Path, str],
-    *,
-    indent=2,
-    separators=None,
-    cls=CirqEncoder,
+    obj: Any, file_or_fn: IO | pathlib.Path | str, *, indent=2, separators=None, cls=CirqEncoder
 ) -> None:
     pass
 
@@ -496,12 +477,12 @@ def to_json(
 
 def to_json(
     obj: Any,
-    file_or_fn: Union[None, IO, pathlib.Path, str] = None,
+    file_or_fn: None | IO | pathlib.Path | str = None,
     *,
-    indent: Optional[int] = 2,
-    separators: Optional[Tuple[str, str]] = None,
-    cls: Type[json.JSONEncoder] = CirqEncoder,
-) -> Optional[str]:
+    indent: int | None = 2,
+    separators: tuple[str, str] | None = None,
+    cls: type[json.JSONEncoder] = CirqEncoder,
+) -> str | None:
     """Write a JSON file containing a representation of obj.
 
     The object may be a cirq object or have data members that are cirq
@@ -538,10 +519,10 @@ def to_json(
 
 # pylint: enable=function-redefined
 def read_json(
-    file_or_fn: Union[None, IO, pathlib.Path, str] = None,
+    file_or_fn: None | IO | pathlib.Path | str = None,
     *,
-    json_text: Optional[str] = None,
-    resolvers: Optional[Sequence[JsonResolver]] = None,
+    json_text: str | None = None,
+    resolvers: Sequence[JsonResolver] | None = None,
 ):
     """Read a JSON file that optionally contains cirq objects.
 
@@ -585,11 +566,11 @@ def read_json(
 
 def to_json_gzip(
     obj: Any,
-    file_or_fn: Union[None, IO, pathlib.Path, str] = None,
+    file_or_fn: None | IO | pathlib.Path | str = None,
     *,
     indent: int = 2,
-    cls: Type[json.JSONEncoder] = CirqEncoder,
-) -> Optional[bytes]:
+    cls: type[json.JSONEncoder] = CirqEncoder,
+) -> bytes | None:
     """Write a gzipped JSON file containing a representation of obj.
 
     The object may be a cirq object or have data members that are cirq
@@ -624,10 +605,10 @@ def to_json_gzip(
 
 
 def read_json_gzip(
-    file_or_fn: Union[None, IO, pathlib.Path, str] = None,
+    file_or_fn: None | IO | pathlib.Path | str = None,
     *,
-    gzip_raw: Optional[bytes] = None,
-    resolvers: Optional[Sequence[JsonResolver]] = None,
+    gzip_raw: bytes | None = None,
+    resolvers: Sequence[JsonResolver] | None = None,
 ):
     """Read a gzipped JSON file that optionally contains cirq objects.
 

cirq/protocols/json_serialization_test.py

@@ -23,7 +23,6 @@ import json
 import os
 import pathlib
 import warnings
-from typing import Dict, List, Optional, Tuple, Type
 from unittest import mock
 
 import attrs
@@ -48,7 +47,7 @@ class _ModuleDeprecation:
 
 
 # tested modules and their deprecation settings
-TESTED_MODULES: Dict[str, Optional[_ModuleDeprecation]] = {
+TESTED_MODULES: dict[str, _ModuleDeprecation | None] = {
     'cirq_aqt': None,
     'cirq_ionq': None,
     'cirq_google': None,
@@ -66,7 +65,7 @@ if np.__version__.startswith("2."):  # pragma: no cover
     del TESTED_MODULES["cirq_rigetti"]
 
 
-def _get_testspecs_for_modules() -> List[ModuleJsonTestSpec]:
+def _get_testspecs_for_modules() -> list[ModuleJsonTestSpec]:
     modules = []
     for m in TESTED_MODULES.keys():
         try:
@@ -359,9 +358,9 @@ class SBKImpl(cirq.SerializableByKey):
     def __init__(
         self,
         name: str,
-        data_list: Optional[List] = None,
-        data_tuple: Optional[Tuple] = None,
-        data_dict: Optional[Dict] = None,
+        data_list: list | None = None,
+        data_tuple: tuple | None = None,
+        data_dict: dict | None = None,
     ):
         self.name = name
         self.data_list = data_list or []
@@ -526,7 +525,7 @@ def test_json_test_data_coverage(mod_spec: ModuleJsonTestSpec, cirq_obj_name: st
 
 @dataclasses.dataclass
 class SerializableTypeObject:
-    test_type: Type
+    test_type: type
 
     def _json_dict_(self):
         return {'test_type': json_serialization.json_cirq_type(self.test_type)}
@@ -607,9 +606,9 @@ def test_to_from_json_gzip():
         _ = cirq.read_json_gzip()
 
 
-def _eval_repr_data_file(path: pathlib.Path, deprecation_deadline: Optional[str]):
+def _eval_repr_data_file(path: pathlib.Path, deprecation_deadline: str | None):
     content = path.read_text()
-    ctx_managers: List[contextlib.AbstractContextManager] = [contextlib.suppress()]
+    ctx_managers: list[contextlib.AbstractContextManager] = [contextlib.suppress()]
     if deprecation_deadline:  # pragma: no cover
         # we ignore coverage here, because sometimes there are no deprecations at all in any of the
         # modules
@@ -639,7 +638,7 @@ def assert_repr_and_json_test_data_agree(
     repr_path: pathlib.Path,
     json_path: pathlib.Path,
     inward_only: bool,
-    deprecation_deadline: Optional[str],
+    deprecation_deadline: str | None,
 ):
     if not repr_path.exists() and not json_path.exists():
         return