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

cirq/interop/quirk/cells/cell.py

@@ -15,19 +15,7 @@
 from __future__ import annotations
 
 import abc
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Iterable,
-    List,
-    NamedTuple,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import Any, Callable, Iterable, NamedTuple, Sequence, TYPE_CHECKING, Union
 
 from cirq import devices, ops, value
 
@@ -44,7 +32,7 @@ class Cell(metaclass=abc.ABCMeta):
     """
 
     @classmethod
-    def _replace_qubit(cls, old_qubit: cirq.Qid, qubits: List[cirq.Qid]) -> cirq.Qid:
+    def _replace_qubit(cls, old_qubit: cirq.Qid, qubits: list[cirq.Qid]) -> cirq.Qid:
         if not isinstance(old_qubit, devices.LineQubit):
             raise ValueError(f'Can only map from line qubits, but got {old_qubit!r}.')
         if not 0 <= old_qubit.x < len(qubits):
@@ -53,12 +41,12 @@ class Cell(metaclass=abc.ABCMeta):
 
     @classmethod
     def _replace_qubits(
-        cls, old_qubits: Iterable[cirq.Qid], qubits: List[cirq.Qid]
-    ) -> Tuple[cirq.Qid, ...]:
+        cls, old_qubits: Iterable[cirq.Qid], qubits: list[cirq.Qid]
+    ) -> tuple[cirq.Qid, ...]:
         return tuple(Cell._replace_qubit(e, qubits) for e in old_qubits)
 
     @abc.abstractmethod
-    def with_line_qubits_mapped_to(self, qubits: List[cirq.Qid]) -> Cell:
+    def with_line_qubits_mapped_to(self, qubits: list[cirq.Qid]) -> Cell:
         """Returns the same cell, but targeting different qubits.
 
         It is assumed that the cell is currently targeting `LineQubit`
@@ -87,7 +75,7 @@ class Cell(metaclass=abc.ABCMeta):
         extremely adversarial conditions.
         """
 
-    def with_input(self, letter: str, register: Union[Sequence[cirq.Qid], int]) -> Cell:
+    def with_input(self, letter: str, register: Sequence[cirq.Qid] | int) -> Cell:
         """The same cell, but linked to an explicit input register or constant.
 
         If the cell doesn't need the input, it is returned unchanged.
@@ -146,7 +134,7 @@ class Cell(metaclass=abc.ABCMeta):
         """
         return ()
 
-    def modify_column(self, column: List[Optional[Cell]]) -> None:
+    def modify_column(self, column: list[Cell | None]) -> None:
         """Applies this cell's modification to its column.
 
         For example, a control cell will add a control qubit to other operations
@@ -162,7 +150,7 @@ class Cell(metaclass=abc.ABCMeta):
             Nothing. The `column` argument is mutated in place.
         """
 
-    def persistent_modifiers(self) -> Dict[str, Callable[[Cell], Cell]]:
+    def persistent_modifiers(self) -> dict[str, Callable[[Cell], Cell]]:
         """Overridable modifications to apply to the rest of the circuit.
 
         Persistent modifiers apply to all cells in the same column and also to
@@ -189,7 +177,7 @@ class ExplicitOperationsCell(Cell):
     def gate_count(self) -> int:
         return len(self._operations) + 2 * len(self._basis_change)
 
-    def with_line_qubits_mapped_to(self, qubits: List[cirq.Qid]) -> Cell:
+    def with_line_qubits_mapped_to(self, qubits: list[cirq.Qid]) -> Cell:
         return ExplicitOperationsCell(
             operations=tuple(
                 op.with_qubits(*Cell._replace_qubits(op.qubits, qubits)) for op in self._operations

cirq/interop/quirk/cells/composite_cell.py

@@ -14,18 +14,7 @@
 
 from __future__ import annotations
 
-from typing import (
-    Callable,
-    cast,
-    Iterable,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    TYPE_CHECKING,
-    TypeVar,
-    Union,
-)
+from typing import Callable, cast, Iterable, Iterator, Sequence, TYPE_CHECKING, TypeVar
 
 from cirq import circuits
 from cirq.interop.quirk.cells.cell import Cell
@@ -41,11 +30,7 @@ class CompositeCell(Cell):
     """
 
     def __init__(
-        self,
-        height: int,
-        sub_cell_cols_generator: Iterable[List[Optional[Cell]]],
-        *,
-        gate_count: int,
+        self, height: int, sub_cell_cols_generator: Iterable[list[Cell | None]], *, gate_count: int
     ):
         """Inits CompositeCell.
 
@@ -93,15 +78,15 @@ class CompositeCell(Cell):
             gate_count=self._gate_count,
         )
 
-    def _sub_cell_cols_sealed(self) -> List[List[Optional[Cell]]]:
+    def _sub_cell_cols_sealed(self) -> list[list[Cell | None]]:
         if not isinstance(self._sub_cell_cols_generator, list):
             self._sub_cell_cols_generator = list(self._sub_cell_cols_generator)
-        return cast(List[List[Optional[Cell]]], self._sub_cell_cols_generator)
+        return cast(list[list[Cell | None]], self._sub_cell_cols_generator)
 
-    def with_line_qubits_mapped_to(self, qubits: List[cirq.Qid]) -> Cell:
+    def with_line_qubits_mapped_to(self, qubits: list[cirq.Qid]) -> Cell:
         return self._transform_cells(lambda cell: cell.with_line_qubits_mapped_to(qubits))
 
-    def with_input(self, letter: str, register: Union[Sequence[cirq.Qid], int]) -> CompositeCell:
+    def with_input(self, letter: str, register: Sequence[cirq.Qid] | int) -> CompositeCell:
         return self._transform_cells(lambda cell: cell.with_input(letter, register))
 
     def controlled_by(self, qubit: cirq.Qid) -> CompositeCell:
@@ -129,7 +114,7 @@ T = TypeVar('T')
 
 def _iterator_to_iterable(iterator: Iterator[T]) -> Iterable[T]:
     done = False
-    items: List[T] = []
+    items: list[T] = []
 
     class IterIntoItems:
         def __iter__(self):

cirq/interop/quirk/cells/control_cells.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Iterable, Iterator, List, Optional, TYPE_CHECKING, Union
+from typing import Any, Iterable, Iterator, TYPE_CHECKING
 
 from cirq import ops, value
 from cirq.interop.quirk.cells.cell import Cell, CellMaker
@@ -44,7 +44,7 @@ class ControlCell(Cell):
     def gate_count(self) -> int:
         return 0
 
-    def with_line_qubits_mapped_to(self, qubits: List[cirq.Qid]) -> Cell:
+    def with_line_qubits_mapped_to(self, qubits: list[cirq.Qid]) -> Cell:
         return ControlCell(
             qubit=Cell._replace_qubit(self.qubit, qubits),
             basis_change=tuple(
@@ -53,7 +53,7 @@ class ControlCell(Cell):
             ),
         )
 
-    def modify_column(self, column: List[Optional[Cell]]):
+    def modify_column(self, column: list[Cell | None]):
         for i in range(len(column)):
             gate = column[i]
             if gate is not None:
@@ -88,7 +88,7 @@ class ParityControlCell(Cell):
     def gate_count(self) -> int:
         return 0
 
-    def with_line_qubits_mapped_to(self, qubits: List[cirq.Qid]) -> Cell:
+    def with_line_qubits_mapped_to(self, qubits: list[cirq.Qid]) -> Cell:
         return ParityControlCell(
             qubits=Cell._replace_qubits(self.qubits, qubits),
             basis_change=tuple(
@@ -97,7 +97,7 @@ class ParityControlCell(Cell):
             ),
         )
 
-    def modify_column(self, column: List[Optional[Cell]]):
+    def modify_column(self, column: list[Cell | None]):
         for i in range(len(column)):
             gate = column[i]
             if gate is self:
@@ -134,7 +134,7 @@ def generate_all_control_cell_makers() -> Iterator[CellMaker]:
     yield _reg_parity_control("zpar", basis_change=None)
 
 
-def _reg_control(identifier: str, *, basis_change: Optional[cirq.Gate]) -> CellMaker:
+def _reg_control(identifier: str, *, basis_change: cirq.Gate | None) -> CellMaker:
     return CellMaker(
         identifier=identifier,
         size=1,
@@ -144,7 +144,7 @@ def _reg_control(identifier: str, *, basis_change: Optional[cirq.Gate]) -> CellM
     )
 
 
-def _reg_parity_control(identifier: str, *, basis_change: Optional[cirq.Gate] = None) -> CellMaker:
+def _reg_parity_control(identifier: str, *, basis_change: cirq.Gate | None = None) -> CellMaker:
     return CellMaker(
         identifier=identifier,
         size=1,
@@ -155,7 +155,7 @@ def _reg_parity_control(identifier: str, *, basis_change: Optional[cirq.Gate] =
 
 
 def _basis_else_empty(
-    basis_change: Optional[cirq.Gate], qureg: Union[cirq.Qid, Iterable[cirq.Qid]]
+    basis_change: cirq.Gate | None, qureg: cirq.Qid | Iterable[cirq.Qid]
 ) -> Iterable[cirq.Operation]:
     if basis_change is None:
         return ()

cirq/interop/quirk/cells/input_cells.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Iterable, Iterator, List, Optional, TYPE_CHECKING
+from typing import Iterable, Iterator, TYPE_CHECKING
 
 from cirq.interop.quirk.cells.cell import Cell, CELL_SIZES, CellMaker
 
@@ -32,10 +32,10 @@ class InputCell(Cell):
     def gate_count(self) -> int:
         return 0
 
-    def with_line_qubits_mapped_to(self, qubits: List[cirq.Qid]) -> Cell:
+    def with_line_qubits_mapped_to(self, qubits: list[cirq.Qid]) -> Cell:
         return InputCell(qubits=Cell._replace_qubits(self.qubits, qubits), letter=self.letter)
 
-    def modify_column(self, column: List[Optional[Cell]]):
+    def modify_column(self, column: list[Cell | None]):
         for i in range(len(column)):
             cell = column[i]
             if cell is not None:
@@ -52,7 +52,7 @@ class SetDefaultInputCell(Cell):
     def gate_count(self) -> int:
         return 0
 
-    def with_line_qubits_mapped_to(self, qubits: List[cirq.Qid]) -> Cell:
+    def with_line_qubits_mapped_to(self, qubits: list[cirq.Qid]) -> Cell:
         return self
 
     def persistent_modifiers(self):

cirq/interop/quirk/cells/input_rotation_cells.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Iterable, Iterator, List, Optional, Sequence, Tuple, Union
+from typing import Any, Iterable, Iterator, Sequence
 
 import numpy as np
 
@@ -30,7 +30,7 @@ class InputRotationCell(Cell):
     def __init__(
         self,
         identifier: str,
-        register: Optional[Sequence[cirq.Qid]],
+        register: Sequence[cirq.Qid] | None,
         base_operation: cirq.Operation,
         exponent_sign: int,
     ):
@@ -54,7 +54,7 @@ class InputRotationCell(Cell):
     def gate_count(self) -> int:
         return 1
 
-    def with_line_qubits_mapped_to(self, qubits: List[cirq.Qid]) -> Cell:
+    def with_line_qubits_mapped_to(self, qubits: list[cirq.Qid]) -> Cell:
         return InputRotationCell(
             self.identifier,
             None if self.register is None else Cell._replace_qubits(self.register, qubits),
@@ -64,7 +64,7 @@ class InputRotationCell(Cell):
             exponent_sign=self.exponent_sign,
         )
 
-    def with_input(self, letter: str, register: Union[Sequence[cirq.Qid], int]) -> Cell:
+    def with_input(self, letter: str, register: Sequence[cirq.Qid] | int) -> Cell:
         # Parameterized rotations use input A as their parameter.
         if self.register is None and letter == 'a':
             if isinstance(register, int):
@@ -115,7 +115,7 @@ class QuirkInputRotationOperation(ops.Operation):
         return (self.identifier, self.register, self.base_operation, self.exponent_sign)
 
     @property
-    def qubits(self) -> Tuple[cirq.Qid, ...]:
+    def qubits(self) -> tuple[cirq.Qid, ...]:
         return tuple(self.base_operation.qubits) + self.register
 
     def with_qubits(self, *new_qubits):

cirq/interop/quirk/cells/parse.py

@@ -20,22 +20,19 @@ from typing import (
     Any,
     Callable,
     cast,
-    Dict,
     Iterable,
     Iterator,
-    List,
     Mapping,
-    Optional,
     SupportsFloat,
+    TypeAlias,
     TypeVar,
-    Union,
 )
 
 import numpy as np
 import sympy
 
 
-def _merge_scientific_float_tokens(tokens: Iterable[str]) -> List[str]:
+def _merge_scientific_float_tokens(tokens: Iterable[str]) -> list[str]:
     tokens = list(tokens)
     i = 0
     while 'e' in tokens[i + 1 :]:
@@ -56,8 +53,8 @@ def _merge_scientific_float_tokens(tokens: Iterable[str]) -> List[str]:
 T = TypeVar('T')
 
 
-def _segment_by(seq: Iterable[T], *, key: Callable[[T], Any]) -> Iterator[List[T]]:
-    group: List[T] = []
+def _segment_by(seq: Iterable[T], *, key: Callable[[T], Any]) -> Iterator[list[T]]:
+    group: list[T] = []
     last_key = None
     for item in seq:
         item_key = key(item)
@@ -70,8 +67,8 @@ def _segment_by(seq: Iterable[T], *, key: Callable[[T], Any]) -> Iterator[List[T
         yield group
 
 
-def _tokenize(text: str) -> List[str]:
-    def classify(e: str) -> Union[str, float]:
+def _tokenize(text: str) -> list[str]:
+    def classify(e: str) -> str | float:
         assert e.strip() != ''  # Because _segment_by drops empty entries.
         if re.match(r'[.0-9]', e):
             return "#"
@@ -87,14 +84,14 @@ def _tokenize(text: str) -> List[str]:
     return _merge_scientific_float_tokens(g for g in result if g.strip())
 
 
-_ResolvedToken = Union[sympy.Expr, complex]
+_ResolvedToken: TypeAlias = sympy.Expr | complex
 
 
 class _CustomQuirkOperationToken:
     def __init__(
         self,
-        unary_action: Optional[Callable[[_ResolvedToken], _ResolvedToken]],
-        binary_action: Optional[Callable[[_ResolvedToken, _ResolvedToken], _ResolvedToken]],
+        unary_action: Callable[[_ResolvedToken], _ResolvedToken] | None,
+        binary_action: Callable[[_ResolvedToken, _ResolvedToken], _ResolvedToken] | None,
         priority: float,
     ):
         self.unary_action = unary_action
@@ -110,7 +107,7 @@ class _HangingNode:
         self.weight = weight
 
 
-_HangingToken = Union[_ResolvedToken, str, _CustomQuirkOperationToken]
+_HangingToken: TypeAlias = _ResolvedToken | str | _CustomQuirkOperationToken
 
 
 def _translate_token(token_id: str, token_map: Mapping[str, _HangingToken]) -> _HangingToken:
@@ -124,10 +121,10 @@ def _translate_token(token_id: str, token_map: Mapping[str, _HangingToken]) -> _
 
 
 def _parse_formula_using_token_map(
-    text: str, token_map: Dict[str, _HangingToken]
+    text: str, token_map: dict[str, _HangingToken]
 ) -> _ResolvedToken:
     """Parses a value from an infix arithmetic expression."""
-    tokens: List[_HangingToken] = [_translate_token(e, token_map) for e in _tokenize(text)]
+    tokens: list[_HangingToken] = [_translate_token(e, token_map) for e in _tokenize(text)]
 
     # Cut off trailing operation, so parse fails less often as users are typing.
     if (
@@ -137,8 +134,8 @@ def _parse_formula_using_token_map(
     ):
         tokens = tokens[:-1]
 
-    ops: List[Union[str, _HangingNode]] = []
-    vals: List[Optional[_HangingToken]] = []
+    ops: list[str | _HangingNode] = []
+    vals: list[_HangingToken | None] = []
 
     # Hack: use the 'priority' field as a signal of 'is an operation'
     def is_valid_end_token(tok: _HangingToken) -> bool:
@@ -147,7 +144,7 @@ def _parse_formula_using_token_map(
     def is_valid_end_state() -> bool:
         return len(vals) == 1 and len(ops) == 0
 
-    def apply(op: Union[str, _HangingNode]) -> None:
+    def apply(op: str | _HangingNode) -> None:
         assert isinstance(op, _HangingNode)
         if len(vals) < 2:
             raise ValueError("Bad expression: operated on nothing.\ntext={text!r}")
@@ -239,7 +236,7 @@ UNICODE_FRACTIONS = {
     "⅒": 1 / 10,
 }
 
-PARSE_COMPLEX_TOKEN_MAP_ALL: Dict[str, _HangingToken] = {
+PARSE_COMPLEX_TOKEN_MAP_ALL: dict[str, _HangingToken] = {
     **UNICODE_FRACTIONS,
     'i': 1j,
     'e': sympy.E,
@@ -267,7 +264,7 @@ PARSE_COMPLEX_TOKEN_MAP_ALL: Dict[str, _HangingToken] = {
 }
 PARSE_COMPLEX_TOKEN_MAP_ALL["√"] = PARSE_COMPLEX_TOKEN_MAP_ALL["sqrt"]
 
-PARSE_COMPLEX_TOKEN_MAP_DEG: Dict[str, _HangingToken] = {
+PARSE_COMPLEX_TOKEN_MAP_DEG: dict[str, _HangingToken] = {
     **PARSE_COMPLEX_TOKEN_MAP_ALL,
     "cos": _CustomQuirkOperationToken(
         unary_action=lambda e: sympy.cos(e * sympy.pi / 180), binary_action=None, priority=4
@@ -285,7 +282,7 @@ PARSE_COMPLEX_TOKEN_MAP_DEG: Dict[str, _HangingToken] = {
 PARSE_COMPLEX_TOKEN_MAP_DEG["arccos"] = PARSE_COMPLEX_TOKEN_MAP_DEG["acos"]
 PARSE_COMPLEX_TOKEN_MAP_DEG["arcsin"] = PARSE_COMPLEX_TOKEN_MAP_DEG["asin"]
 
-PARSE_COMPLEX_TOKEN_MAP_RAD: Dict[str, _HangingToken] = {
+PARSE_COMPLEX_TOKEN_MAP_RAD: dict[str, _HangingToken] = {
     **PARSE_COMPLEX_TOKEN_MAP_ALL,
     "cos": _CustomQuirkOperationToken(
         unary_action=lambda e: sympy.cos(e) if isinstance(e, sympy.Basic) else cmath.cos(e),
@@ -339,12 +336,12 @@ def parse_complex(text: str) -> complex:
         raise ValueError(f'Failed to parse complex from {text!r}') from ex
 
 
-def parse_formula(formula: str) -> Union[float, sympy.Expr]:
+def parse_formula(formula: str) -> float | sympy.Expr:
     """Attempts to parse formula text in exactly the same way as Quirk."""
     if not isinstance(formula, str):
         raise TypeError('formula must be a string')
 
-    token_map: Dict[str, _HangingToken] = {**PARSE_COMPLEX_TOKEN_MAP_RAD, 't': sympy.Symbol('t')}
+    token_map: dict[str, _HangingToken] = {**PARSE_COMPLEX_TOKEN_MAP_RAD, 't': sympy.Symbol('t')}
     result = _parse_formula_using_token_map(formula, token_map)
 
     if isinstance(result, sympy.Basic):

cirq/interop/quirk/cells/qubit_permutation_cells.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Callable, Iterator, Sequence, Tuple, TYPE_CHECKING
+from typing import Callable, Iterator, Sequence, TYPE_CHECKING
 
 from cirq import ops, value
 from cirq.interop.quirk.cells.cell import CELL_SIZES, CellMaker
@@ -44,7 +44,7 @@ class QuirkQubitPermutationGate(ops.QubitPermutationGate):
     def _value_equality_values_(self):
         return self.identifier, self.name, self.permutation
 
-    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> Tuple[str, ...]:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> tuple[str, ...]:
         return tuple(
             f'{self.name}[{i}>{self.permutation[i]}]' for i in range(len(self.permutation))
         )
@@ -74,7 +74,7 @@ def _permutation_family(
         yield _permutation(identifier_prefix + str(n), name, permutation)
 
 
-def _permutation(identifier: str, name: str, permutation: Tuple[int, ...]) -> CellMaker:
+def _permutation(identifier: str, name: str, permutation: tuple[int, ...]) -> CellMaker:
     return CellMaker(
         identifier,
         size=len(permutation),

cirq/interop/quirk/cells/swap_cell.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Iterable, Iterator, List, Optional, TYPE_CHECKING
+from typing import Any, Iterable, Iterator, TYPE_CHECKING
 
 from cirq import ops, value
 from cirq.interop.quirk.cells.cell import Cell, CellMaker
@@ -32,13 +32,13 @@ class SwapCell(Cell):
     def gate_count(self) -> int:
         return 1
 
-    def with_line_qubits_mapped_to(self, qubits: List[cirq.Qid]) -> Cell:
+    def with_line_qubits_mapped_to(self, qubits: list[cirq.Qid]) -> Cell:
         return SwapCell(
             qubits=Cell._replace_qubits(self._qubits, qubits),
             controls=Cell._replace_qubits(self._controls, qubits),
         )
 
-    def modify_column(self, column: List[Optional[Cell]]):
+    def modify_column(self, column: list[Cell | None]):
         # Swallow other swap cells.
         for i in range(len(column)):
             gate = column[i]

cirq/interop/quirk/cells/testing.py

@@ -14,8 +14,6 @@
 
 from __future__ import annotations
 
-from typing import Dict, List, Optional
-
 import numpy as np
 
 import cirq
@@ -24,12 +22,12 @@ from cirq import quirk_url_to_circuit
 
 def assert_url_to_circuit_returns(
     json_text: str,
-    circuit: Optional[cirq.Circuit] = None,
+    circuit: cirq.Circuit | None = None,
     *,
-    unitary: Optional[np.ndarray] = None,
-    diagram: Optional[str] = None,
-    output_amplitudes_from_quirk: Optional[List[Dict[str, float]]] = None,
-    maps: Optional[Dict[int, int]] = None,
+    unitary: np.ndarray | None = None,
+    diagram: str | None = None,
+    output_amplitudes_from_quirk: list[dict[str, float]] | None = None,
+    maps: dict[int, int] | None = None,
 ):
     """Assert that `quirk_url_to_circuit` functions correctly.
 

cirq/interop/quirk/url_to_circuit.py

@@ -16,19 +16,7 @@ from __future__ import annotations
 
 import json
 import urllib.parse
-from typing import (
-    Any,
-    cast,
-    Dict,
-    Iterable,
-    List,
-    Mapping,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import Any, cast, Iterable, Mapping, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -50,10 +38,8 @@ if TYPE_CHECKING:
 def quirk_url_to_circuit(
     quirk_url: str,
     *,
-    qubits: Optional[Sequence[cirq.Qid]] = None,
-    extra_cell_makers: Union[
-        Dict[str, cirq.Gate], Iterable[cirq.interop.quirk.cells.CellMaker]
-    ] = (),
+    qubits: Sequence[cirq.Qid] | None = None,
+    extra_cell_makers: dict[str, cirq.Gate] | Iterable[cirq.interop.quirk.cells.CellMaker] = (),
     max_operation_count: int = 10**6,
 ) -> cirq.Circuit:
     """Parses a Cirq circuit out of a Quirk URL.
@@ -153,11 +139,9 @@ def quirk_url_to_circuit(
 def quirk_json_to_circuit(
     data: dict,
     *,
-    qubits: Optional[Sequence[cirq.Qid]] = None,
-    extra_cell_makers: Union[
-        Dict[str, cirq.Gate], Iterable[cirq.interop.quirk.cells.CellMaker]
-    ] = (),
-    quirk_url: Optional[str] = None,
+    qubits: Sequence[cirq.Qid] | None = None,
+    extra_cell_makers: dict[str, cirq.Gate] | Iterable[cirq.interop.quirk.cells.CellMaker] = (),
+    quirk_url: str | None = None,
     max_operation_count: int = 10**6,
 ) -> cirq.Circuit:
     """Constructs a Cirq circuit from Quirk's JSON format.
@@ -258,9 +242,9 @@ def quirk_json_to_circuit(
 
 
 def _parse_cols_into_composite_cell(
-    data: Dict[str, Any], registry: Dict[str, CellMaker]
+    data: dict[str, Any], registry: dict[str, CellMaker]
 ) -> CompositeCell:
-    if not isinstance(data, Dict):
+    if not isinstance(data, dict):
         raise ValueError('Circuit JSON must be a dictionary.')
     if 'cols' not in data:
         raise ValueError(f'Circuit JSON dict must have a "cols" entry.\nJSON={data}')
@@ -269,7 +253,7 @@ def _parse_cols_into_composite_cell(
         raise ValueError(f'Circuit JSON cols must be a list.\nJSON={data}')
 
     # Parse column json into cells.
-    parsed_cols: List[List[Optional[Cell]]] = []
+    parsed_cols: list[list[Cell | None]] = []
     height = 0
     for i, col in enumerate(cols):
         parsed_col, h = _parse_col_cells_with_height(registry, i, col)
@@ -303,8 +287,8 @@ def _parse_cols_into_composite_cell(
     return CompositeCell(height, parsed_cols, gate_count=gate_count)
 
 
-def _register_custom_gate(gate_json: Any, registry: Dict[str, CellMaker]):
-    if not isinstance(gate_json, Dict):
+def _register_custom_gate(gate_json: Any, registry: dict[str, CellMaker]):
+    if not isinstance(gate_json, dict):
         raise ValueError(f'Custom gate json must be a dictionary.\nCustom gate json={gate_json!r}.')
 
     if 'id' not in gate_json:
@@ -346,11 +330,11 @@ def _register_custom_gate(gate_json: Any, registry: Dict[str, CellMaker]):
         )
 
 
-def _init_ops(data: Dict[str, Any]) -> cirq.OP_TREE:
+def _init_ops(data: dict[str, Any]) -> cirq.OP_TREE:
     if 'init' not in data:
         return []
     init = data['init']
-    if not isinstance(init, List):
+    if not isinstance(init, list):
         raise ValueError(f'Circuit JSON init must be a list but was {init!r}.')
     init_ops = []
     for i in range(len(init)):
@@ -374,8 +358,8 @@ def _init_ops(data: Dict[str, Any]) -> cirq.OP_TREE:
 
 
 def _parse_col_cells_with_height(
-    registry: Dict[str, CellMaker], col: int, col_data: Any
-) -> Tuple[List[Optional[Cell]], int]:
+    registry: dict[str, CellMaker], col: int, col_data: Any
+) -> tuple[list[Cell | None], int]:
     if not isinstance(col_data, list):
         raise ValueError(f'col must be a list.\ncol: {col_data!r}')
     result = []
@@ -388,8 +372,8 @@ def _parse_col_cells_with_height(
 
 
 def _parse_cell_with_height(
-    registry: Dict[str, CellMaker], row: int, col: int, entry: Any
-) -> Tuple[Optional[Cell], int]:
+    registry: dict[str, CellMaker], row: int, col: int, entry: Any
+) -> tuple[Cell | None, int]:
     if entry == 1:
         return None, 0
 

cirq/json_resolver_cache.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 
 import datetime
 import functools
-from typing import Dict, List, NamedTuple, Optional, Tuple, TYPE_CHECKING
+from typing import NamedTuple, TYPE_CHECKING
 
 if TYPE_CHECKING:
     import cirq
@@ -32,18 +32,18 @@ SpecklePurityPair = NamedTuple('SpecklePurityPair', [('num_cycle', int), ('purit
 CrossEntropyResult = NamedTuple(
     'CrossEntropyResult',
     [
-        ('data', List[CrossEntropyPair]),
+        ('data', list[CrossEntropyPair]),
         ('repetitions', int),
-        ('purity_data', Optional[List[SpecklePurityPair]]),
+        ('purity_data', list[SpecklePurityPair] | None),
     ],
 )
 CrossEntropyResultDict = NamedTuple(
-    'CrossEntropyResultDict', [('results', Dict[Tuple['cirq.Qid', ...], CrossEntropyResult])]
+    'CrossEntropyResultDict', [('results', dict[tuple['cirq.Qid', ...], CrossEntropyResult])]
 )
 
 
 @functools.lru_cache()
-def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
+def _class_resolver_dictionary() -> dict[str, ObjectFactory]:
     import numpy as np
     import pandas as pd
 
@@ -82,7 +82,7 @@ def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
         )
 
     def _cross_entropy_result_dict(
-        results: List[Tuple[List[cirq.Qid], CrossEntropyResult]], **kwargs
+        results: list[tuple[list[cirq.Qid], CrossEntropyResult]], **kwargs
     ) -> CrossEntropyResultDict:
         return CrossEntropyResultDict(results={tuple(qubits): result for qubits, result in results})