cirq-core 1.5.0.dev20250409222543__py3-none-any.whl → 1.6.0__py3-none-any.whl

cirq/ops/two_qubit_diagonal_gate.py

@@ -18,7 +18,9 @@ The gate is used to create a 4x4 matrix with the diagonal elements
 passed as a list.
 """
 
-from typing import AbstractSet, Any, Dict, Iterator, Optional, Sequence, Tuple, TYPE_CHECKING
+from __future__ import annotations
+
+from typing import AbstractSet, Any, Iterator, Sequence, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -62,10 +64,10 @@ class TwoQubitDiagonalGate(raw_types.Gate):
                 If these values are $(x_0, x_1, \ldots , x_3)$ then the unitary
                 has diagonal values $(e^{i x_0}, e^{i x_1}, \ldots, e^{i x_3})$.
         """
-        self._diag_angles_radians: Tuple[value.TParamVal, ...] = tuple(diag_angles_radians)
+        self._diag_angles_radians: tuple[value.TParamVal, ...] = tuple(diag_angles_radians)
 
     @property
-    def diag_angles_radians(self) -> Tuple[value.TParamVal, ...]:
+    def diag_angles_radians(self) -> tuple[value.TParamVal, ...]:
         return self._diag_angles_radians
 
     def _num_qubits_(self) -> int:
@@ -80,8 +82,8 @@ class TwoQubitDiagonalGate(raw_types.Gate):
         }
 
     def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'TwoQubitDiagonalGate':
+        self, resolver: cirq.ParamResolver, recursive: bool
+    ) -> TwoQubitDiagonalGate:
         return TwoQubitDiagonalGate(
             protocols.resolve_parameters(self._diag_angles_radians, resolver, recursive)
         )
@@ -89,12 +91,12 @@ class TwoQubitDiagonalGate(raw_types.Gate):
     def _has_unitary_(self) -> bool:
         return not self._is_parameterized_()
 
-    def _unitary_(self) -> Optional[np.ndarray]:
+    def _unitary_(self) -> np.ndarray | None:
         if self._is_parameterized_():
             return None
         return np.diag([np.exp(1j * angle) for angle in self._diag_angles_radians])
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> Iterator['cirq.OP_TREE']:
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
         x0, x1, x2, x3 = self._diag_angles_radians
         q0, q1 = qubits
         yield common_gates.ZPowGate(exponent=x2 / np.pi).on(q0)
@@ -104,7 +106,7 @@ class TwoQubitDiagonalGate(raw_types.Gate):
         yield common_gates.CZPowGate(exponent=x0 / np.pi).on(q0, q1)
         yield common_gates.XPowGate().on_each(q0, q1)
 
-    def _apply_unitary_(self, args: 'protocols.ApplyUnitaryArgs') -> np.ndarray:
+    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> np.ndarray:
         if self._is_parameterized_():
             return NotImplemented
         for index, angle in enumerate(self._diag_angles_radians):
@@ -112,16 +114,14 @@ class TwoQubitDiagonalGate(raw_types.Gate):
             args.target_tensor[subspace_index] *= np.exp(1j * angle)
         return args.target_tensor
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         rounded_angles = np.array(self._diag_angles_radians)
         if args.precision is not None:
             rounded_angles = rounded_angles.round(args.precision)
         diag_str = f"diag({', '.join(proper_repr(angle) for angle in rounded_angles)})"
         return protocols.CircuitDiagramInfo((diag_str, '#2'))
 
-    def __pow__(self, exponent: Any) -> 'TwoQubitDiagonalGate':
+    def __pow__(self, exponent: Any) -> TwoQubitDiagonalGate:
         if not isinstance(exponent, (int, float, sympy.Basic)):
             return NotImplemented
         angles = []
@@ -139,5 +139,5 @@ class TwoQubitDiagonalGate(raw_types.Gate):
         angles = ','.join(proper_repr(angle) for angle in self._diag_angles_radians)
         return f'cirq.TwoQubitDiagonalGate([{angles}])'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, attribute_names=["diag_angles_radians"])

cirq/ops/two_qubit_diagonal_gate_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import numpy as np
 import pytest
 import sympy
@@ -30,15 +32,15 @@ import cirq
         )
     ),
 )
-def test_consistent_protocols(gate):
+def test_consistent_protocols(gate) -> None:
     cirq.testing.assert_implements_consistent_protocols(gate)
 
 
-def test_property():
+def test_property() -> None:
     assert cirq.TwoQubitDiagonalGate([2, 3, 5, 7]).diag_angles_radians == (2, 3, 5, 7)
 
 
-def test_parameterized_decompose():
+def test_parameterized_decompose() -> None:
     angles = sympy.symbols('x0, x1, x2, x3')
     parameterized_op = cirq.TwoQubitDiagonalGate(angles).on(*cirq.LineQubit.range(2))
     decomposed_circuit = cirq.Circuit(cirq.decompose(parameterized_op))
@@ -54,7 +56,7 @@ def test_parameterized_decompose():
         )
 
 
-def test_unitary():
+def test_unitary() -> None:
     diagonal_angles = [2, 3, 5, 7]
     assert cirq.has_unitary(cirq.TwoQubitDiagonalGate(diagonal_angles))
     np.testing.assert_allclose(
@@ -64,7 +66,7 @@ def test_unitary():
     )
 
 
-def test_diagram():
+def test_diagram() -> None:
     a, b = cirq.LineQubit.range(2)
 
     diagonal_circuit = cirq.Circuit(cirq.TwoQubitDiagonalGate([2, 3, 5, 7])(a, b))
@@ -87,7 +89,7 @@ def test_diagram():
     )
 
 
-def test_diagonal_exponent():
+def test_diagonal_exponent() -> None:
     diagonal_angles = [2, 3, 5, 7]
     diagonal_gate = cirq.TwoQubitDiagonalGate(diagonal_angles)
 
@@ -99,7 +101,7 @@ def test_diagonal_exponent():
     assert cirq.pow(cirq.TwoQubitDiagonalGate(diagonal_angles), "test", None) is None
 
 
-def test_protocols_mul_not_implemented():
+def test_protocols_mul_not_implemented() -> None:
     diagonal_angles = [2, 3, None, 7]
     diagonal_gate = cirq.TwoQubitDiagonalGate(diagonal_angles)
     with pytest.raises(TypeError):
@@ -107,7 +109,7 @@ def test_protocols_mul_not_implemented():
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_resolve(resolve_fn):
+def test_resolve(resolve_fn) -> None:
     diagonal_angles = [2, 3, 5, 7]
     diagonal_gate = cirq.TwoQubitDiagonalGate(
         diagonal_angles[:2] + [sympy.Symbol('a'), sympy.Symbol('b')]

cirq/ops/uniform_superposition_gate.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Dict, Iterator, Sequence, TYPE_CHECKING
+from __future__ import annotations
+
+from typing import Any, Iterator, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -58,7 +60,7 @@ class UniformSuperpositionGate(raw_types.Gate):
         self._m_value = m_value
         self._num_qubits = num_qubits
 
-    def _decompose_(self, qubits: Sequence["cirq.Qid"]) -> Iterator["cirq.OP_TREE"]:
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
         """Decomposes the gate into a sequence of standard gates.
         Implements the construction from https://arxiv.org/pdf/2306.11747.
         """
@@ -113,7 +115,7 @@ class UniformSuperpositionGate(raw_types.Gate):
     def __repr__(self) -> str:
         return f'UniformSuperpositionGate(m_value={self._m_value}, num_qubits={self._num_qubits})'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         d = {}
         d['m_value'] = self._m_value
         d['num_qubits'] = self._num_qubits

cirq/ops/uniform_superposition_gate_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import numpy as np
 import pytest
 
@@ -65,18 +67,18 @@ def test_incompatible_m_value_and_qubit_args(m: int, n: int) -> None:
             cirq.UniformSuperpositionGate(m, n)
 
 
-def test_repr():
+def test_repr() -> None:
     assert (
         repr(cirq.UniformSuperpositionGate(7, 3))
         == 'UniformSuperpositionGate(m_value=7, num_qubits=3)'
     )
 
 
-def test_uniform_superposition_gate_json_dict():
+def test_uniform_superposition_gate_json_dict() -> None:
     assert cirq.UniformSuperpositionGate(7, 3)._json_dict_() == {'m_value': 7, 'num_qubits': 3}
 
 
-def test_str():
+def test_str() -> None:
     assert (
         str(cirq.UniformSuperpositionGate(7, 3))
         == 'UniformSuperpositionGate(m_value=7, num_qubits=3)'

cirq/ops/wait_gate.py

@@ -11,7 +11,10 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from typing import AbstractSet, Any, Dict, Optional, Tuple, TYPE_CHECKING
+
+from __future__ import annotations
+
+from typing import AbstractSet, Any, TYPE_CHECKING
 
 from cirq import protocols, value
 from cirq.ops import raw_types
@@ -30,9 +33,9 @@ class WaitGate(raw_types.Gate):
 
     def __init__(
         self,
-        duration: 'cirq.DURATION_LIKE',
-        num_qubits: Optional[int] = None,
-        qid_shape: Optional[Tuple[int, ...]] = None,
+        duration: cirq.DURATION_LIKE | int,
+        num_qubits: int | None = None,
+        qid_shape: tuple[int, ...] | None = None,
     ) -> None:
         """Initialize a wait gate with the given duration.
 
@@ -66,7 +69,7 @@ class WaitGate(raw_types.Gate):
         self._qid_shape = qid_shape
 
     @property
-    def duration(self) -> 'cirq.Duration':
+    def duration(self) -> cirq.Duration:
         return self._duration
 
     def _is_parameterized_(self) -> bool:
@@ -75,13 +78,13 @@ class WaitGate(raw_types.Gate):
     def _parameter_names_(self) -> AbstractSet[str]:
         return protocols.parameter_names(self.duration)
 
-    def _resolve_parameters_(self, resolver: 'cirq.ParamResolver', recursive: bool) -> 'WaitGate':
+    def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> WaitGate:
         return WaitGate(
             protocols.resolve_parameters(self.duration, resolver, recursive),
             qid_shape=self._qid_shape,
         )
 
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return self._qid_shape
 
     def _has_unitary_(self) -> bool:
@@ -111,7 +114,7 @@ class WaitGate(raw_types.Gate):
     def __repr__(self) -> str:
         return f'cirq.WaitGate({repr(self.duration)})'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         d = protocols.obj_to_dict_helper(self, ['duration'])
         if len(self._qid_shape) != 1:
             d['num_qubits'] = len(self._qid_shape)
@@ -132,12 +135,12 @@ class WaitGate(raw_types.Gate):
 
 
 def wait(
-    *target: 'cirq.Qid',
-    duration: 'cirq.DURATION_LIKE' = None,
-    picos: 'cirq.TParamVal' = 0,
-    nanos: 'cirq.TParamVal' = 0,
-    micros: 'cirq.TParamVal' = 0,
-    millis: 'cirq.TParamVal' = 0,
+    *target: cirq.Qid,
+    duration: cirq.DURATION_LIKE = None,
+    picos: cirq.TParamVal = 0,
+    nanos: cirq.TParamVal = 0,
+    micros: cirq.TParamVal = 0,
+    millis: cirq.TParamVal = 0,
 ) -> raw_types.Operation:
     """Creates a WaitGate applied to all the given qubits.
 

cirq/ops/wait_gate_test.py

@@ -11,6 +11,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+from __future__ import annotations
+
 import datetime
 
 import pytest
@@ -19,7 +22,7 @@ import sympy
 import cirq
 
 
-def test_init():
+def test_init() -> None:
     g = cirq.WaitGate(datetime.timedelta(0, 0, 5))
     assert g.duration == cirq.Duration(micros=5)
 
@@ -36,13 +39,13 @@ def test_init():
         _ = cirq.WaitGate(2)
 
 
-def test_eq():
+def test_eq() -> None:
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(cirq.WaitGate(0), cirq.WaitGate(cirq.Duration()))
     eq.make_equality_group(lambda: cirq.WaitGate(cirq.Duration(nanos=4)))
 
 
-def test_protocols():
+def test_protocols() -> None:
     t = sympy.Symbol('t')
     p = cirq.WaitGate(cirq.Duration(millis=5 * t))
     c = cirq.WaitGate(cirq.Duration(millis=2))
@@ -67,7 +70,7 @@ def test_protocols():
     assert cirq.decompose(p.on(q)) == []
 
 
-def test_qid_shape():
+def test_qid_shape() -> None:
     assert cirq.qid_shape(cirq.WaitGate(0, qid_shape=(2, 3))) == (2, 3)
     assert cirq.qid_shape(cirq.WaitGate(0, num_qubits=3)) == (2, 2, 2)
     with pytest.raises(ValueError, match='empty set of qubits'):
@@ -84,7 +87,7 @@ def test_resolve_parameters(num_qubits: int) -> None:
     assert cirq.num_qubits(resolved) == num_qubits
 
 
-def test_json():
+def test_json() -> None:
     q0, q1 = cirq.GridQubit.rect(1, 2)
     qtrit = cirq.GridQid(1, 2, dimension=3)
     cirq.testing.assert_json_roundtrip_works(cirq.wait(q0, nanos=10))
@@ -93,5 +96,5 @@ def test_json():
     cirq.testing.assert_json_roundtrip_works(cirq.wait(qtrit, q1, nanos=10))
 
 
-def test_str():
+def test_str() -> None:
     assert str(cirq.WaitGate(cirq.Duration(nanos=5))) == 'WaitGate(5 ns)'

cirq/protocols/__init__.py

@@ -139,11 +139,8 @@ from cirq.protocols.pauli_expansion_protocol import (
     SupportsPauliExpansion as SupportsPauliExpansion,
 )
 
-# pylint: disable=redefined-builtin
 from cirq.protocols.pow_protocol import pow as pow
 
-# pylint: enable=redefined-builtin
-
 from cirq.protocols.qasm import (
     qasm as qasm,
     QasmArgs as QasmArgs,

cirq/protocols/act_on_protocol.py

@@ -12,8 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from types import NotImplementedType
-from typing import Any, Optional, Sequence, TYPE_CHECKING, Union
+from typing import Any, Sequence, TYPE_CHECKING
 
 from typing_extensions import Protocol
 
@@ -28,7 +30,7 @@ class SupportsActOn(Protocol):
     """An object that explicitly specifies how to act on simulator states."""
 
     @doc_private
-    def _act_on_(self, sim_state: 'cirq.SimulationStateBase') -> Union[NotImplementedType, bool]:
+    def _act_on_(self, sim_state: cirq.SimulationStateBase) -> NotImplementedType | bool:
         """Applies an action to the given argument, if it is a supported type.
 
         For example, unitary operations can implement an `_act_on_` method that
@@ -59,8 +61,8 @@ class SupportsActOnQubits(Protocol):
 
     @doc_private
     def _act_on_(
-        self, sim_state: 'cirq.SimulationStateBase', qubits: Sequence['cirq.Qid']
-    ) -> Union[NotImplementedType, bool]:
+        self, sim_state: cirq.SimulationStateBase, qubits: Sequence[cirq.Qid]
+    ) -> NotImplementedType | bool:
         """Applies an action to the given argument, if it is a supported type.
 
         For example, unitary operations can implement an `_act_on_` method that
@@ -88,8 +90,8 @@ class SupportsActOnQubits(Protocol):
 
 def act_on(
     action: Any,
-    sim_state: 'cirq.SimulationStateBase',
-    qubits: Optional[Sequence['cirq.Qid']] = None,
+    sim_state: cirq.SimulationStateBase,
+    qubits: Sequence[cirq.Qid] | None = None,
     *,
     allow_decompose: bool = True,
 ):

cirq/protocols/act_on_protocol_test.py

@@ -11,7 +11,10 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from typing import Any, Sequence, Tuple
+
+from __future__ import annotations
+
+from typing import Any, Sequence
 
 import numpy as np
 import pytest
@@ -34,7 +37,7 @@ class ExampleSimulationState(cirq.SimulationState):
         self.fallback_result = fallback_result
 
     def _act_on_fallback_(
-        self, action: Any, qubits: Sequence['cirq.Qid'], allow_decompose: bool = True
+        self, action: Any, qubits: Sequence[cirq.Qid], allow_decompose: bool = True
     ):
         return self.fallback_result
 
@@ -42,30 +45,30 @@ class ExampleSimulationState(cirq.SimulationState):
 op = cirq.X(cirq.LineQubit(0))
 
 
-def test_act_on_fallback_succeeds():
+def test_act_on_fallback_succeeds() -> None:
     state = ExampleSimulationState(fallback_result=True)
     cirq.act_on(op, state)
 
 
-def test_act_on_fallback_fails():
+def test_act_on_fallback_fails() -> None:
     state = ExampleSimulationState(fallback_result=NotImplemented)
     with pytest.raises(TypeError, match='Failed to act'):
         cirq.act_on(op, state)
 
 
-def test_act_on_fallback_errors():
+def test_act_on_fallback_errors() -> None:
     state = ExampleSimulationState(fallback_result=False)
     with pytest.raises(ValueError, match='_act_on_fallback_ must return True or NotImplemented'):
         cirq.act_on(op, state)
 
 
-def test_act_on_errors():
+def test_act_on_errors() -> None:
     class Op(cirq.Operation):
         @property
-        def qubits(self) -> Tuple['cirq.Qid', ...]:  # type: ignore[empty-body]
+        def qubits(self) -> tuple[cirq.Qid, ...]:  # type: ignore[empty-body]
             pass
 
-        def with_qubits(self, *new_qubits: 'cirq.Qid') -> Self:  # type: ignore[empty-body]
+        def with_qubits(self, *new_qubits: cirq.Qid) -> Self:  # type: ignore[empty-body]
             pass
 
         def _act_on_(self, sim_state):
@@ -76,13 +79,13 @@ def test_act_on_errors():
         cirq.act_on(Op(), state)
 
 
-def test_qubits_not_allowed_for_operations():
+def test_qubits_not_allowed_for_operations() -> None:
     class Op(cirq.Operation):
         @property
-        def qubits(self) -> Tuple['cirq.Qid', ...]:  # type: ignore[empty-body]
+        def qubits(self) -> tuple[cirq.Qid, ...]:  # type: ignore[empty-body]
             pass
 
-        def with_qubits(self, *new_qubits: 'cirq.Qid') -> Self:  # type: ignore[empty-body]
+        def with_qubits(self, *new_qubits: cirq.Qid) -> Self:  # type: ignore[empty-body]
             pass
 
     state = ExampleSimulationState()
@@ -92,7 +95,7 @@ def test_qubits_not_allowed_for_operations():
         cirq.act_on(Op(), state, qubits=[])
 
 
-def test_qubits_should_be_defined_for_operations():
+def test_qubits_should_be_defined_for_operations() -> None:
     state = ExampleSimulationState()
     with pytest.raises(ValueError, match='Calls to act_on should'):
         cirq.act_on(cirq.KrausChannel([np.array([[1, 0], [0, 0]])]), state, qubits=None)

cirq/protocols/apply_channel_protocol.py

@@ -14,8 +14,10 @@
 
 """A protocol for implementing high performance channel evolutions."""
 
+from __future__ import annotations
+
 from types import NotImplementedType
-from typing import Any, Iterable, Optional, Sequence, Tuple, TypeVar, Union
+from typing import Any, Iterable, Sequence, TypeVar
 
 import numpy as np
 from typing_extensions import Protocol
@@ -124,9 +126,7 @@ class SupportsApplyChannel(Protocol):
     """An object that can efficiently implement a channel."""
 
     @doc_private
-    def _apply_channel_(
-        self, args: ApplyChannelArgs
-    ) -> Union[np.ndarray, None, NotImplementedType]:
+    def _apply_channel_(self, args: ApplyChannelArgs) -> np.ndarray | None | NotImplementedType:
         """Efficiently applies a channel.
 
         This method is given both the target tensor and workspace of the same
@@ -166,10 +166,8 @@ class SupportsApplyChannel(Protocol):
 
 
 def apply_channel(
-    val: Any,
-    args: ApplyChannelArgs,
-    default: Union[np.ndarray, TDefault] = RaiseTypeErrorIfNotProvided,
-) -> Union[np.ndarray, TDefault]:
+    val: Any, args: ApplyChannelArgs, default: np.ndarray | TDefault = RaiseTypeErrorIfNotProvided
+) -> np.ndarray | TDefault:
     """High performance evolution under a channel evolution.
 
     If `val` defines an `_apply_channel_` method, that method will be
@@ -273,7 +271,7 @@ def apply_channel(
     )
 
 
-def _apply_unitary(val: Any, args: 'ApplyChannelArgs') -> Optional[np.ndarray]:
+def _apply_unitary(val: Any, args: ApplyChannelArgs) -> np.ndarray | None:
     """Attempt to use `apply_unitary` and return the result.
 
     If `val` does not support `apply_unitary` returns None.
@@ -296,9 +294,7 @@ def _apply_unitary(val: Any, args: 'ApplyChannelArgs') -> Optional[np.ndarray]:
     return right_result
 
 
-def _apply_kraus(
-    kraus: Union[Tuple[np.ndarray], Sequence[Any]], args: 'ApplyChannelArgs'
-) -> np.ndarray:
+def _apply_kraus(kraus: tuple[np.ndarray] | Sequence[Any], args: ApplyChannelArgs) -> np.ndarray:
     """Directly apply the kraus operators to the target tensor."""
     # Initialize output.
     args.out_buffer[:] = 0
@@ -313,7 +309,7 @@ def _apply_kraus(
 
 
 def _apply_kraus_single_qubit(
-    kraus: Union[Tuple[Any], Sequence[Any]], args: 'ApplyChannelArgs'
+    kraus: tuple[Any] | Sequence[Any], args: ApplyChannelArgs
 ) -> np.ndarray:
     """Use slicing to apply single qubit channel.  Only for two-level qubits."""
     zero_left = linalg.slice_for_qubits_equal_to(args.left_axes, 0)
@@ -338,7 +334,7 @@ def _apply_kraus_single_qubit(
 
 
 def _apply_kraus_multi_qubit(
-    kraus: Union[Tuple[Any], Sequence[Any]], args: 'ApplyChannelArgs'
+    kraus: tuple[Any] | Sequence[Any], args: ApplyChannelArgs
 ) -> np.ndarray:
     """Use numpy's einsum to apply a multi-qubit channel."""
     qid_shape = tuple(args.target_tensor.shape[i] for i in args.left_axes)

cirq/protocols/apply_channel_protocol_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import numpy as np
 import pytest