Update types for standard collections (#7355)

- Updates typing for collections for the following:
-    typing.Dict to dict
-    typing.List to list
-    typing.Tuple to tuple

This has been in python since 3.9 (2000). It's time to update all of
this.

This is only typing changes, except for a few isinstance checks.

Author: dstrain115

benchmarks/circuit_construction.py

@@ -12,17 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import itertools
-from typing import Sequence, Set, Tuple
+from typing import Sequence
 
 import cirq
 
 
 def rotated_surface_code_memory_z_cycle(
-    data_qubits: Set[cirq.Qid],
-    z_measure_qubits: Set[cirq.Qid],
-    x_measure_qubits: Set[cirq.Qid],
-    z_order: Sequence[Tuple[int, int]],
-    x_order: Sequence[Tuple[int, int]],
+    data_qubits: set[cirq.Qid],
+    z_measure_qubits: set[cirq.Qid],
+    x_measure_qubits: set[cirq.Qid],
+    z_order: Sequence[tuple[int, int]],
+    x_order: Sequence[tuple[int, int]],
 ) -> cirq.Circuit:
     """Constructs a circuit for a single round of rotated memory Z surface code.
 
@@ -77,7 +77,7 @@ def surface_code_circuit(
         A `cirq.Circuit` for surface code memory Z experiment for `distance` and `num_rounds`.
     """
 
-    def ndrange(*ranges: Tuple[int, ...]):
+    def ndrange(*ranges: tuple[int, ...]):
         return itertools.product(*[range(*r) for r in ranges])
 
     data_qubits = {cirq.q(2 * x + 1, 2 * y + 1) for x, y in ndrange((distance,), (distance,))}

benchmarks/randomized_benchmarking.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 import functools
-from typing import List, Sequence
+from typing import Sequence
 
 import numpy as np
 
@@ -46,12 +46,12 @@ def setup(self, *_):
                 for group in _single_qubit_cliffords().c1_in_xz
             ]
         )
-        self.sq_xz_cliffords: List[cirq.Gate] = [
+        self.sq_xz_cliffords: list[cirq.Gate] = [
             cirq.PhasedXZGate.from_matrix(mat) for mat in self.sq_xz_matrices
         ]
 
-    def _get_op_grid(self, qubits: List[cirq.Qid], depth: int) -> List[List[cirq.Operation]]:
-        op_grid: List[List[cirq.Operation]] = []
+    def _get_op_grid(self, qubits: list[cirq.Qid], depth: int) -> list[list[cirq.Operation]]:
+        op_grid: list[list[cirq.Operation]] = []
         for q in qubits:
             gate_ids = np.random.choice(len(self.sq_xz_cliffords), depth)
             idx = _find_inv_matrix(dot(self.sq_xz_matrices[gate_ids][::-1]), self.sq_xz_matrices)

cirq-core/cirq/_compat.py

@@ -28,7 +28,7 @@
 import traceback
 import warnings
 from types import ModuleType
-from typing import Any, Callable, Dict, Iterator, Optional, overload, Set, Tuple, Type, TypeVar
+from typing import Any, Callable, Iterator, overload, TypeVar
 
 import numpy as np
 import pandas as pd
@@ -79,7 +79,7 @@ def cached_method(__func: TFunc) -> TFunc: ...
 def cached_method(*, maxsize: int = 128) -> Callable[[TFunc], TFunc]: ...
 
 
-def cached_method(method: Optional[TFunc] = None, *, maxsize: int = 128) -> Any:
+def cached_method(method: TFunc | None = None, *, maxsize: int = 128) -> Any:
     """Decorator that adds a per-instance LRU cache for a method.
 
     Can be applied with or without parameters to customize the underlying cache:
@@ -195,7 +195,7 @@ def _print(self, expr, **kwargs):
             f'\n)'
         )
 
-    if isinstance(value, Dict):
+    if isinstance(value, dict):
         return '{' + ','.join(f"{proper_repr(k)}: {proper_repr(v)}" for k, v in value.items()) + '}'
 
     if hasattr(value, "__qualname__"):
@@ -288,7 +288,7 @@ def _validate_deadline(deadline: str):
 
 
 def deprecated(
-    *, deadline: str, fix: str, name: Optional[str] = None
+    *, deadline: str, fix: str, name: str | None = None
 ) -> Callable[[Callable], Callable]:
     """Marks a function as deprecated.
 
@@ -329,9 +329,7 @@ def decorated_func(*args, **kwargs) -> Any:
     return decorator
 
 
-def deprecated_class(
-    *, deadline: str, fix: str, name: Optional[str] = None
-) -> Callable[[Type], Type]:
+def deprecated_class(*, deadline: str, fix: str, name: str | None = None) -> Callable[[type], type]:
     """Marks a class as deprecated.
 
     Args:
@@ -348,7 +346,7 @@ def deprecated_class(
 
     _validate_deadline(deadline)
 
-    def decorator(clazz: Type) -> Type:
+    def decorator(clazz: type) -> type:
         clazz_new = clazz.__new__
 
         def patched_new(cls, *args, **kwargs):
@@ -378,12 +376,12 @@ def deprecated_parameter(
     *,
     deadline: str,
     fix: str,
-    func_name: Optional[str] = None,
+    func_name: str | None = None,
     parameter_desc: str,
-    match: Callable[[Tuple[Any, ...], Dict[str, Any]], bool],
-    rewrite: Optional[
-        Callable[[Tuple[Any, ...], Dict[str, Any]], Tuple[Tuple[Any, ...], Dict[str, Any]]]
-    ] = None,
+    match: Callable[[tuple[Any, ...], dict[str, Any]], bool],
+    rewrite: (
+        Callable[[tuple[Any, ...], dict[str, Any]], tuple[tuple[Any, ...], dict[str, Any]]] | None
+    ) = None,
 ) -> Callable[[Callable], Callable]:
     """Marks a function parameter as deprecated.
 
@@ -447,7 +445,7 @@ async def async_decorated_func(*args, **kwargs) -> Any:
     return decorator
 
 
-def deprecate_attributes(module_name: str, deprecated_attributes: Dict[str, Tuple[str, str]]):
+def deprecate_attributes(module_name: str, deprecated_attributes: dict[str, tuple[str, str]]):
     """Replace module with a wrapper that gives warnings for deprecated attributes.
 
     Args:
@@ -586,7 +584,7 @@ def _is_internal(filename: str) -> bool:
     return 'importlib' in filename and '_bootstrap' in filename
 
 
-_warned: Set[str] = set()
+_warned: set[str] = set()
 
 
 def _called_from_test() -> bool:
@@ -635,7 +633,7 @@ def __init__(
         new_module_name: str,
         old_module_name: str,
         deadline: str,
-        broken_module_exception: Optional[BaseException],
+        broken_module_exception: BaseException | None,
     ):
         """An aliasing module finder that uses existing module finders to find a python
         module spec and intercept the execution of matching modules.
@@ -763,7 +761,7 @@ def _setup_deprecated_submodule_attribute(
     old_parent: str,
     old_child: str,
     deadline: str,
-    new_module: Optional[ModuleType],
+    new_module: ModuleType | None,
 ):
     parent_module = sys.modules[old_parent]
     setattr(parent_module, old_child, new_module)

cirq-core/cirq/_compat_test.py

@@ -27,7 +27,7 @@
 import warnings
 from importlib.machinery import ModuleSpec
 from types import ModuleType
-from typing import Any, Callable, Dict, Optional, Tuple
+from typing import Any, Callable
 from unittest import mock
 
 import duet
@@ -764,7 +764,6 @@ def test_metadata_search_path():
 def _test_metadata_search_path_inner():  # pragma: no cover
     # initialize the DeprecatedModuleFinders
     # pylint: disable=unused-import
-    import cirq.testing._compat_test_data.module_a
 
     assert importlib.metadata.metadata('numpy')
 
@@ -882,8 +881,6 @@ def _test_new_module_is_top_level_inner():
     # imports a top level module that was also deprecated
     from freezegun import api
 
-    import cirq.testing._compat_test_data
-
     assert api.real_time == time.time
 
 
@@ -925,7 +922,7 @@ class EmptyLoader(importlib.abc.Loader):
     fake_mod = ModuleType('hello')
 
     class CreateModuleLoader(importlib.abc.Loader):
-        def create_module(self, spec: ModuleSpec) -> Optional[ModuleType]:
+        def create_module(self, spec: ModuleSpec) -> ModuleType | None:
             return fake_mod
 
     assert (
@@ -1017,16 +1014,16 @@ def f(x):
 
 class Bar:
     def __init__(self) -> None:
-        self.foo_calls: Dict[int, int] = collections.Counter()
-        self.bar_calls: Dict[int, int] = collections.Counter()
+        self.foo_calls: dict[int, int] = collections.Counter()
+        self.bar_calls: dict[int, int] = collections.Counter()
 
     @cached_method
-    def foo(self, n: int) -> Tuple[int, int]:
+    def foo(self, n: int) -> tuple[int, int]:
         self.foo_calls[n] += 1
         return (id(self), n)
 
     @cached_method(maxsize=1)
-    def bar(self, n: int) -> Tuple[int, int]:
+    def bar(self, n: int) -> tuple[int, int]:
         self.bar_calls[n] += 1
         return (id(self), 2 * n)
 

cirq-core/cirq/_doc.py

@@ -15,9 +15,9 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict
+from typing import Any
 
-RECORDED_CONST_DOCS: Dict[int, str] = {}
+RECORDED_CONST_DOCS: dict[int, str] = {}
 
 
 def document(value: Any, doc_string: str = ''):

cirq-core/cirq/_import.py

@@ -21,7 +21,7 @@
 from importlib.abc import Loader
 from importlib.machinery import ModuleSpec
 from types import ModuleType
-from typing import Any, Callable, cast, List, Optional
+from typing import Any, Callable, cast
 
 
 class InstrumentedFinder(abc.MetaPathFinder):
@@ -31,7 +31,7 @@ def __init__(
         self,
         finder: Any,
         module_name: str,
-        wrap_module: Callable[[ModuleType], Optional[ModuleType]],
+        wrap_module: Callable[[ModuleType], ModuleType | None],
         after_exec: Callable[[ModuleType], None],
     ):
         """A module finder that uses an existing module finder to find a python
@@ -56,7 +56,7 @@ def __init__(
 
         self.finder = finder
         self.module_name = module_name
-        self.match_components: List[str] = []
+        self.match_components: list[str] = []
         if self.module_name:
             self.match_components = self.module_name.split('.')
         self.wrap_module = wrap_module
@@ -82,7 +82,7 @@ class InstrumentedLoader(abc.Loader):
     def __init__(
         self,
         loader: Any,
-        wrap_module: Callable[[ModuleType], Optional[ModuleType]],
+        wrap_module: Callable[[ModuleType], ModuleType | None],
         after_exec: Callable[[ModuleType], None],
     ):
         """A module loader that uses an existing module loader and intercepts
@@ -121,7 +121,7 @@ def exec_module(self, module: ModuleType) -> None:
 @contextmanager
 def wrap_module_executions(
     module_name: str,
-    wrap_func: Callable[[ModuleType], Optional[ModuleType]],
+    wrap_func: Callable[[ModuleType], ModuleType | None],
     after_exec: Callable[[ModuleType], None] = lambda m: None,
     assert_meta_path_unchanged: bool = True,
 ):
@@ -157,7 +157,7 @@ def delay_import(module_name: str):
     delay = True
     execute_list = []
 
-    def wrap_func(module: ModuleType) -> Optional[ModuleType]:
+    def wrap_func(module: ModuleType) -> ModuleType | None:
         if delay:
             execute_list.append(module)
             return None  # Don't allow the module to be executed yet

cirq-core/cirq/circuits/_block_diagram_drawer.py

@@ -15,7 +15,6 @@
 from __future__ import annotations
 
 import collections
-from typing import Dict, List, Optional, Tuple
 
 from cirq.circuits._box_drawing_character_data import box_draw_character, BoxDrawCharacterSet
 
@@ -57,7 +56,7 @@ def draw_curve(
         left: bool = False,
         right: bool = False,
         bottom: bool = False,
-        crossing_char: Optional[str] = None,
+        crossing_char: str | None = None,
     ):
         """Draws lines in the box using the given character set.
 
@@ -107,7 +106,7 @@ def draw_curve(
 
         self._prev_curve_grid_chars = grid_characters
 
-    def render(self, width: int, height: int) -> List[str]:
+    def render(self, width: int, height: int) -> list[str]:
         """Returns a list of text lines representing the block's contents.
 
         Args:
@@ -159,9 +158,9 @@ class BlockDiagramDrawer:
     """Aligns text and curve data placed onto an abstract 2d grid of blocks."""
 
     def __init__(self) -> None:
-        self._blocks: Dict[Tuple[int, int], Block] = collections.defaultdict(Block)
-        self._min_widths: Dict[int, int] = collections.defaultdict(lambda: 0)
-        self._min_heights: Dict[int, int] = collections.defaultdict(lambda: 0)
+        self._blocks: dict[tuple[int, int], Block] = collections.defaultdict(Block)
+        self._min_widths: dict[int, int] = collections.defaultdict(lambda: 0)
+        self._min_heights: dict[int, int] = collections.defaultdict(lambda: 0)
 
         # Populate the origin.
         _ = self._blocks[(0, 0)]
@@ -189,8 +188,8 @@ def set_row_min_height(self, y: int, min_height: int):
     def render(
         self,
         *,
-        block_span_x: Optional[int] = None,
-        block_span_y: Optional[int] = None,
+        block_span_x: int | None = None,
+        block_span_y: int | None = None,
         min_block_width: int = 0,
         min_block_height: int = 0,
     ) -> str:
@@ -252,10 +251,10 @@ def block(x: int, y: int) -> Block:
         }
 
         # Paste together all of the rows of rendered block content.
-        out_lines: List[str] = []
+        out_lines: list[str] = []
         for y in range(block_span_y):
             for by in range(heights[y]):
-                out_line_chunks: List[str] = []
+                out_line_chunks: list[str] = []
                 for x in range(block_span_x):
                     out_line_chunks.extend(block_renders[x, y][by])
                 out_lines.append(''.join(out_line_chunks).rstrip())