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

cirq/testing/consistent_channels_test.py

@@ -12,18 +12,20 @@
 # 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 cirq
 
 
-def test_assert_consistent_channel_valid():
+def test_assert_consistent_channel_valid() -> None:
     channel = cirq.KrausChannel(kraus_ops=(np.array([[0, 1], [0, 0]]), np.array([[1, 0], [0, 0]])))
     cirq.testing.assert_consistent_channel(channel)
 
 
-def test_assert_consistent_channel_tolerances():
+def test_assert_consistent_channel_tolerances() -> None:
     # This channel is off by 1e-5 from the identity matrix in the consistency condition.
     channel = cirq.KrausChannel(
         kraus_ops=(np.array([[0, np.sqrt(1 - 1e-5)], [0, 0]]), np.array([[1, 0], [0, 0]]))
@@ -37,23 +39,23 @@ def test_assert_consistent_channel_tolerances():
         cirq.testing.assert_consistent_channel(channel, rtol=0, atol=1e-6)
 
 
-def test_assert_consistent_channel_invalid():
+def test_assert_consistent_channel_invalid() -> None:
     channel = cirq.KrausChannel(kraus_ops=(np.array([[1, 1], [0, 0]]), np.array([[1, 0], [0, 0]])))
     with pytest.raises(AssertionError, match=r"cirq.KrausChannel.*2 1"):
         cirq.testing.assert_consistent_channel(channel)
 
 
-def test_assert_consistent_channel_not_kraus():
+def test_assert_consistent_channel_not_kraus() -> None:
     with pytest.raises(AssertionError, match="12.*has_kraus"):
         cirq.testing.assert_consistent_channel(12)
 
 
-def test_assert_consistent_mixture_valid():
+def test_assert_consistent_mixture_valid() -> None:
     mixture = cirq.X.with_probability(0.1)
     cirq.testing.assert_consistent_mixture(mixture)
 
 
-def test_assert_consistent_mixture_not_mixture():
+def test_assert_consistent_mixture_not_mixture() -> None:
     not_mixture = cirq.amplitude_damp(0.1)
     with pytest.raises(AssertionError, match="has_mixture"):
         cirq.testing.assert_consistent_mixture(not_mixture)
@@ -69,7 +71,7 @@ class _MixtureGate(cirq.testing.SingleQubitGate):
         return (self._p, cirq.unitary(cirq.I)), (self._q, cirq.unitary(cirq.X))
 
 
-def test_assert_consistent_mixture_not_normalized():
+def test_assert_consistent_mixture_not_normalized() -> None:
     mixture = _MixtureGate(0.1, 0.85)
     with pytest.raises(AssertionError, match="sum to 1"):
         cirq.testing.assert_consistent_mixture(mixture)
@@ -79,7 +81,7 @@ def test_assert_consistent_mixture_not_normalized():
         cirq.testing.assert_consistent_mixture(mixture)
 
 
-def test_assert_consistent_mixture_tolerances():
+def test_assert_consistent_mixture_tolerances() -> None:
 
     # This gate is 1e-5 off being properly normalized.
     mixture = _MixtureGate(0.1, 0.9 - 1e-5)

cirq/testing/consistent_controlled_gate_op.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Collection, Optional, Sequence, Union
+from __future__ import annotations
+
+from typing import Collection, Sequence
 
 import numpy as np
 
@@ -23,7 +25,7 @@ def assert_controlled_and_controlled_by_identical(
     gate: ops.Gate,
     *,
     num_controls: Sequence[int] = (2, 1, 3, 10),
-    control_values: Optional[Sequence[Optional[Sequence[Union[int, Collection[int]]]]]] = None,
+    control_values: Sequence[Sequence[int | Collection[int]] | None] | None = None,
 ) -> None:
     """Checks that gate.on().controlled_by() == gate.controlled().on()"""
     if control_values is not None:
@@ -50,9 +52,7 @@ def assert_controlled_unitary_consistent(gate: ops.Gate):
 
 
 def _assert_gate_consistent(
-    gate: ops.Gate,
-    num_controls: int,
-    control_values: Optional[Sequence[Union[int, Collection[int]]]],
+    gate: ops.Gate, num_controls: int, control_values: Sequence[int | Collection[int]] | None
 ) -> None:
     gate_controlled = gate.controlled(num_controls, control_values)
     qubits = devices.LineQid.for_gate(gate_controlled)

cirq/testing/consistent_controlled_gate_op_test.py

@@ -12,53 +12,53 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Collection, List, Optional, Sequence, Tuple, Union
+from __future__ import annotations
+
+from typing import Collection, Sequence, TYPE_CHECKING
 
 import numpy as np
 import pytest
 
 import cirq
-from cirq.ops import control_values as cv
+
+if TYPE_CHECKING:
+    from cirq.ops import control_values as cv
 
 
 class GoodGate(cirq.EigenGate, cirq.testing.SingleQubitGate):
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:  # pragma: no cover
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:  # pragma: no cover
         return [(0, np.diag([1, 0])), (1, np.diag([0, 1]))]
 
 
 class BadGateOperation(cirq.GateOperation):
     def controlled_by(
         self,
-        *control_qubits: 'cirq.Qid',
-        control_values: Optional[
-            Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
-        ] = None,
-    ) -> 'cirq.Operation':
+        *control_qubits: cirq.Qid,
+        control_values: cv.AbstractControlValues | Sequence[int | Collection[int]] | None = None,
+    ) -> cirq.Operation:
         return cirq.ControlledOperation(control_qubits, self, control_values)
 
 
 class BadGate(cirq.EigenGate, cirq.testing.SingleQubitGate):
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         return [(0, np.diag([1, 0])), (1, np.diag([0, 1]))]
 
-    def on(self, *qubits: 'cirq.Qid') -> 'cirq.Operation':
+    def on(self, *qubits: cirq.Qid) -> cirq.Operation:
         return BadGateOperation(self, list(qubits))
 
     def controlled(
         self,
-        num_controls: Optional[int] = None,
-        control_values: Optional[
-            Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
-        ] = None,
-        control_qid_shape: Optional[Tuple[int, ...]] = None,
-    ) -> 'cirq.Gate':
+        num_controls: int | None = None,
+        control_values: cv.AbstractControlValues | Sequence[int | Collection[int]] | None = None,
+        control_qid_shape: tuple[int, ...] | None = None,
+    ) -> cirq.Gate:
         ret = super().controlled(num_controls, control_values, control_qid_shape)
         if num_controls == 1 and control_values is None:
             return cirq.CZPowGate(exponent=self._exponent, global_shift=self._global_shift)
         return ret
 
 
-def test_assert_controlled_and_controlled_by_identical():
+def test_assert_controlled_and_controlled_by_identical() -> None:
     cirq.testing.assert_controlled_and_controlled_by_identical(GoodGate())
 
     with pytest.raises(AssertionError):
@@ -75,7 +75,7 @@ def test_assert_controlled_and_controlled_by_identical():
         )
 
 
-def test_assert_controlled_unitary_consistent():
+def test_assert_controlled_unitary_consistent() -> None:
     cirq.testing.assert_controlled_and_controlled_by_identical(
         GoodGate(exponent=0.5, global_shift=1 / 3)
     )

cirq/testing/consistent_decomposition.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import Any
 
 import numpy as np
@@ -22,9 +24,7 @@ from cirq.testing import lin_alg_utils
 
 def assert_decompose_is_consistent_with_unitary(val: Any, ignoring_global_phase: bool = False):
     """Uses `val._unitary_` to check `val._phase_by_`'s behavior."""
-    # pylint: disable=unused-variable
     __tracebackhide__ = True
-    # pylint: enable=unused-variable
 
     expected = protocols.unitary(val, None)
     if expected is None:

cirq/testing/consistent_decomposition_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
@@ -35,7 +37,7 @@ class BadGateDecompose(cirq.testing.SingleQubitGate):
         return np.array([[0, 1], [1, 0]])
 
 
-def test_assert_decompose_is_consistent_with_unitary():
+def test_assert_decompose_is_consistent_with_unitary() -> None:
     cirq.testing.assert_decompose_is_consistent_with_unitary(GoodGateDecompose())
 
     cirq.testing.assert_decompose_is_consistent_with_unitary(
@@ -89,7 +91,7 @@ class ParameterizedGate(cirq.Gate):
         yield cirq.Y(qubits[1]) ** sympy.Symbol("y")
 
 
-def test_assert_decompose_ends_at_default_gateset():
+def test_assert_decompose_ends_at_default_gateset() -> None:
     cirq.testing.assert_decompose_ends_at_default_gateset(GateDecomposesToDefaultGateset())
     cirq.testing.assert_decompose_ends_at_default_gateset(
         GateDecomposesToDefaultGateset().on(*cirq.LineQubit.range(2))

cirq/testing/consistent_pauli_expansion.py

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

cirq/testing/consistent_pauli_expansion_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
 
@@ -52,7 +54,7 @@ class BadGateInconsistentPauliExpansion(cirq.testing.SingleQubitGate):
         return cirq.LinearDict({'X': np.sqrt(1 / 6), 'Y': np.sqrt(1 / 3), 'Z': np.sqrt(1 / 2)})
 
 
-def test_assert_pauli_expansion_is_consistent_with_unitary():
+def test_assert_pauli_expansion_is_consistent_with_unitary() -> None:
     cirq.testing.assert_pauli_expansion_is_consistent_with_unitary(GoodGateExplicitPauliExpansion())
     cirq.testing.assert_pauli_expansion_is_consistent_with_unitary(GoodGateNoPauliExpansion())
     cirq.testing.assert_pauli_expansion_is_consistent_with_unitary(GoodGateNoUnitary())

cirq/testing/consistent_phase_by.py

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

cirq/testing/consistent_phase_by_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
 
@@ -89,7 +91,7 @@ class SemiBadPhaser:
         return SemiBadPhaser([resolver.value_of(val, recursive) for val in self.e])
 
 
-def test_assert_phase_by_is_consistent_with_unitary():
+def test_assert_phase_by_is_consistent_with_unitary() -> None:
     cirq.testing.assert_phase_by_is_consistent_with_unitary(GoodPhaser(0.5))
 
     cirq.testing.assert_phase_by_is_consistent_with_unitary(GoodQuditPhaser(0.5))

cirq/testing/consistent_protocols.py

@@ -12,8 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import itertools
-from typing import Any, Dict, Optional, Sequence, Type
+from typing import Any, Sequence
 
 import numpy as np
 import sympy
@@ -47,11 +49,11 @@ def assert_implements_consistent_protocols(
     val: Any,
     *,
     exponents: Sequence[Any] = (0, 1, -1, 0.25, sympy.Symbol('s')),
-    qubit_count: Optional[int] = None,
+    qubit_count: int | None = None,
     ignoring_global_phase: bool = False,
     setup_code: str = 'import cirq\nimport numpy as np\nimport sympy',
-    global_vals: Optional[Dict[str, Any]] = None,
-    local_vals: Optional[Dict[str, Any]] = None,
+    global_vals: dict[str, Any] | None = None,
+    local_vals: dict[str, Any] | None = None,
     ignore_decompose_to_default_gateset: bool = False,
 ) -> None:
     """Checks that a value is internally consistent and has a good __repr__."""
@@ -81,22 +83,20 @@ def assert_implements_consistent_protocols(
 
 
 def assert_eigengate_implements_consistent_protocols(
-    eigen_gate_type: Type[ops.EigenGate],
+    eigen_gate_type: type[ops.EigenGate],
     *,
     exponents: Sequence[value.TParamVal] = (0, 1, -1, 0.25, sympy.Symbol('s')),
     global_shifts: Sequence[float] = (0, -0.5, 0.1),
-    qubit_count: Optional[int] = None,
+    qubit_count: int | None = None,
     ignoring_global_phase: bool = False,
     setup_code: str = 'import cirq\nimport numpy as np\nimport sympy',
-    global_vals: Optional[Dict[str, Any]] = None,
-    local_vals: Optional[Dict[str, Any]] = None,
+    global_vals: dict[str, Any] | None = None,
+    local_vals: dict[str, Any] | None = None,
     ignore_decompose_to_default_gateset: bool = False,
 ) -> None:
     """Checks that an EigenGate subclass is internally consistent and has a
     good __repr__."""
-    # pylint: disable=unused-variable
     __tracebackhide__ = True
-    # pylint: enable=unused-variable
 
     for exponent in exponents:
         for shift in global_shifts:
@@ -111,9 +111,7 @@ def assert_eigengate_implements_consistent_protocols(
 
 
 def assert_eigen_shifts_is_consistent_with_eigen_components(val: ops.EigenGate) -> None:
-    # pylint: disable=unused-variable
     __tracebackhide__ = True
-    # pylint: enable=unused-variable
     if not protocols.is_parameterized(val):
         assert val._eigen_shifts() == [
             e[0] for e in val._eigen_components()
@@ -121,9 +119,7 @@ def assert_eigen_shifts_is_consistent_with_eigen_components(val: ops.EigenGate)
 
 
 def assert_has_consistent_trace_distance_bound(val: Any) -> None:
-    # pylint: disable=unused-variable
     __tracebackhide__ = True
-    # pylint: enable=unused-variable
     u = protocols.unitary(val, default=None)
     val_from_trace = protocols.trace_distance_bound(val)
     assert 0.0 <= val_from_trace <= 1.0
@@ -143,11 +139,11 @@ def _assert_meets_standards_helper(
     *,
     ignoring_global_phase: bool,
     setup_code: str,
-    global_vals: Optional[Dict[str, Any]],
-    local_vals: Optional[Dict[str, Any]],
+    global_vals: dict[str, Any] | None,
+    local_vals: dict[str, Any] | None,
     ignore_decompose_to_default_gateset: bool,
 ) -> None:
-    __tracebackhide__ = True  # pylint: disable=unused-variable
+    __tracebackhide__ = True
 
     assert_consistent_resolve_parameters(val)
     assert_specifies_has_unitary_if_unitary(val)
@@ -174,9 +170,7 @@ def _assert_meets_standards_helper(
             assert_controlled_unitary_consistent(val)
 
 
-def assert_commutes_magic_method_consistent_with_unitaries(
-    *vals: Sequence[Any], atol: float = 1e-8
-) -> None:
+def assert_commutes_magic_method_consistent_with_unitaries(*vals: Any, atol: float = 1e-8) -> None:
     if any(isinstance(val, ops.Operation) for val in vals):
         raise TypeError('`_commutes_` need not be consistent with unitaries for `Operation`.')
     unitaries = [protocols.unitary(val, None) for val in vals]

cirq/testing/consistent_protocols_test.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 AbstractSet, List, Sequence, Tuple, Union
+from typing import AbstractSet, Sequence
 
 import numpy as np
 import pytest
@@ -26,7 +28,7 @@ from cirq._compat import proper_repr
 
 class GoodGate(cirq.testing.SingleQubitGate):
     def __init__(
-        self, *, phase_exponent: Union[float, sympy.Expr], exponent: Union[float, sympy.Expr] = 1.0
+        self, *, phase_exponent: float | sympy.Expr, exponent: float | sympy.Expr = 1.0
     ) -> None:
         self.phase_exponent = cirq.canonicalize_half_turns(phase_exponent)
         self.exponent = exponent
@@ -34,14 +36,14 @@ class GoodGate(cirq.testing.SingleQubitGate):
     def _has_unitary_(self):
         return not cirq.is_parameterized(self)
 
-    def _unitary_(self) -> Union[np.ndarray, NotImplementedType]:
+    def _unitary_(self) -> np.ndarray | NotImplementedType:
         if cirq.is_parameterized(self):
             return NotImplemented
         z = cirq.unitary(cirq.Z**self.phase_exponent)
         x = cirq.unitary(cirq.X**self.exponent)
         return np.dot(np.dot(z, x), np.conj(z))
 
-    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> Union[np.ndarray, NotImplementedType]:
+    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> np.ndarray | NotImplementedType:
         if self.exponent != 1 or cirq.is_parameterized(self):
             return NotImplemented
 
@@ -83,7 +85,7 @@ class GoodGate(cirq.testing.SingleQubitGate):
             exponent=self.exponent, phase_exponent=self.phase_exponent + phase_turns * 2
         )
 
-    def __pow__(self, exponent: Union[float, sympy.Expr]) -> 'GoodGate':
+    def __pow__(self, exponent: float | sympy.Expr) -> GoodGate:
         new_exponent = cirq.mul(self.exponent, exponent, NotImplemented)
         if new_exponent is NotImplemented:
             return NotImplemented  # pragma: no cover
@@ -101,7 +103,7 @@ class GoodGate(cirq.testing.SingleQubitGate):
     def _parameter_names_(self) -> AbstractSet[str]:
         return cirq.parameter_names(self.exponent) | cirq.parameter_names(self.phase_exponent)
 
-    def _resolve_parameters_(self, resolver, recursive) -> 'GoodGate':
+    def _resolve_parameters_(self, resolver, recursive) -> GoodGate:
         return GoodGate(
             phase_exponent=resolver.value_of(self.phase_exponent, recursive),
             exponent=resolver.value_of(self.exponent, recursive),
@@ -127,7 +129,7 @@ class BadGateParameterNames(GoodGate):
 
 
 class BadGateApplyUnitaryToTensor(GoodGate):
-    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> Union[np.ndarray, NotImplementedType]:
+    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> np.ndarray | NotImplementedType:
         if self.exponent != 1 or cirq.is_parameterized(self):
             return NotImplemented  # pragma: no cover
 
@@ -176,7 +178,7 @@ class BadGateRepr(GoodGate):
 
 
 class GoodEigenGate(cirq.EigenGate, cirq.testing.SingleQubitGate):
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         return [(0, np.diag([1, 0])), (1, np.diag([0, 1]))]
 
     def __repr__(self):
@@ -199,7 +201,7 @@ class BadEigenGate(GoodEigenGate):
         )
 
 
-def test_assert_implements_consistent_protocols():
+def test_assert_implements_consistent_protocols() -> None:
     cirq.testing.assert_implements_consistent_protocols(
         GoodGate(phase_exponent=0.0), global_vals={'GoodGate': GoodGate}
     )
@@ -247,7 +249,7 @@ def test_assert_implements_consistent_protocols():
         cirq.testing.assert_implements_consistent_protocols(controlled_gate_op_test.BadGate())
 
 
-def test_assert_eigengate_implements_consistent_protocols():
+def test_assert_eigengate_implements_consistent_protocols() -> None:
     cirq.testing.assert_eigengate_implements_consistent_protocols(
         GoodEigenGate,
         global_vals={'GoodEigenGate': GoodEigenGate},
@@ -262,7 +264,7 @@ def test_assert_eigengate_implements_consistent_protocols():
         )
 
 
-def test_assert_commutes_magic_method_consistent_with_unitaries():
+def test_assert_commutes_magic_method_consistent_with_unitaries() -> None:
     gate_op = cirq.CNOT(*cirq.LineQubit.range(2))
     with pytest.raises(TypeError):
         cirq.testing.assert_commutes_magic_method_consistent_with_unitaries(gate_op)

cirq/testing/consistent_qasm.py

@@ -12,8 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import warnings
-from typing import Any, List, Optional, Sequence
+from typing import Any, Sequence
 
 import numpy as np
 
@@ -85,8 +87,8 @@ qreg q[{num_qubits}];
             qasm_unitary, unitary, rtol=1e-8, atol=1e-8
         )
     except Exception as ex:
-        p_unitary: Optional[np.ndarray]
-        p_qasm_unitary: Optional[np.ndarray]
+        p_unitary: np.ndarray | None
+        p_qasm_unitary: np.ndarray | None
         if qasm_unitary is not None:
             p_unitary, p_qasm_unitary = linalg.match_global_phase(unitary, qasm_unitary)
         else:
@@ -125,7 +127,7 @@ def _indent(*content: str) -> str:
     return '    ' + '\n'.join(content).replace('\n', '\n    ')
 
 
-def _reorder_indices_of_matrix(matrix: np.ndarray, new_order: List[int]):
+def _reorder_indices_of_matrix(matrix: np.ndarray, new_order: list[int]):
     num_qubits = matrix.shape[0].bit_length() - 1
     matrix = np.reshape(matrix, (2,) * 2 * num_qubits)
     all_indices = range(2 * num_qubits)

cirq/testing/consistent_qasm_test.py

@@ -12,8 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
+import importlib.util
 import warnings
-from typing import Tuple
 
 import numpy as np
 import pytest
@@ -41,20 +43,18 @@ class Fixed(cirq.Operation):
 
 
 class QuditGate(cirq.Gate):
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return (3, 3)
 
     def _unitary_(self):
         return np.eye(9)
 
-    def _qasm_(self, args: cirq.QasmArgs, qubits: Tuple[cirq.Qid, ...]):
+    def _qasm_(self, args: cirq.QasmArgs, qubits: tuple[cirq.Qid, ...]):
         return NotImplemented
 
 
-def test_assert_qasm_is_consistent_with_unitary():
-    try:
-        import qiskit as _
-    except ImportError:  # pragma: no cover
+def test_assert_qasm_is_consistent_with_unitary() -> None:
+    if importlib.util.find_spec('qiskit') is None:  # pragma: no cover
         warnings.warn(
             "Skipped test_assert_qasm_is_consistent_with_unitary "
             "because qiskit isn't installed to verify against."

cirq/testing/consistent_resolve_parameters.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import Any
 
 import sympy

cirq/testing/consistent_specified_has_unitary.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import Any
 
 from cirq import protocols
@@ -20,9 +22,7 @@ from cirq import protocols
 def assert_specifies_has_unitary_if_unitary(val: Any) -> None:
     """Checks that unitary values can be cheaply identifies as unitary."""
 
-    # pylint: disable=unused-variable
     __tracebackhide__ = True
-    # pylint: enable=unused-variable
 
     assert not protocols.has_unitary(val) or hasattr(val, '_has_unitary_'), (
         "Value is unitary but doesn't specify a _has_unitary_ method that "

cirq/testing/consistent_specified_has_unitary_test.py

@@ -12,13 +12,15 @@
 # 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 cirq
 
 
-def test_assert_specifies_has_unitary_if_unitary_from_matrix():
+def test_assert_specifies_has_unitary_if_unitary_from_matrix() -> None:
     class Bad:
         def _unitary_(self):
             return np.array([[1]])
@@ -28,7 +30,7 @@ def test_assert_specifies_has_unitary_if_unitary_from_matrix():
         cirq.testing.assert_specifies_has_unitary_if_unitary(Bad())
 
 
-def test_assert_specifies_has_unitary_if_unitary_from_apply():
+def test_assert_specifies_has_unitary_if_unitary_from_apply() -> None:
     class Bad(cirq.Operation):
         @property
         def qubits(self):
@@ -45,7 +47,7 @@ def test_assert_specifies_has_unitary_if_unitary_from_apply():
         cirq.testing.assert_specifies_has_unitary_if_unitary(Bad())
 
 
-def test_assert_specifies_has_unitary_if_unitary_from_decompose():
+def test_assert_specifies_has_unitary_if_unitary_from_decompose() -> None:
     class Bad:
         def _decompose_(self):
             return []
@@ -70,7 +72,7 @@ def test_assert_specifies_has_unitary_if_unitary_from_decompose():
     cirq.testing.assert_specifies_has_unitary_if_unitary(Okay())
 
 
-def test_assert_specifies_has_unitary_if_unitary_pass():
+def test_assert_specifies_has_unitary_if_unitary_pass() -> None:
     class Good:
         def _has_unitary_(self):
             return True

cirq/testing/consistent_unitary.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
 
 from typing import Any
 

cirq/testing/consistent_unitary_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
 
@@ -78,7 +80,7 @@ class CleanCorrectButBorrowableIncorrectGate(cirq.Gate):
         (CleanCorrectButBorrowableIncorrectGate(use_clean_ancilla=False), False),
     ],
 )
-def test_assert_unitary_is_consistent(g, ignore_phase, is_consistent):
+def test_assert_unitary_is_consistent(g, ignore_phase, is_consistent) -> None:
     if is_consistent:
         cirq.testing.assert_unitary_is_consistent(g, ignore_phase)
         cirq.testing.assert_unitary_is_consistent(g.on(*cirq.LineQid.for_gate(g)), ignore_phase)
@@ -89,7 +91,7 @@ def test_assert_unitary_is_consistent(g, ignore_phase, is_consistent):
             cirq.testing.assert_unitary_is_consistent(g.on(*cirq.LineQid.for_gate(g)), ignore_phase)
 
 
-def test_failed_decomposition():
+def test_failed_decomposition() -> None:
     with pytest.raises(ValueError):
         cirq.testing.assert_unitary_is_consistent(FailsOnDecompostion())