cirq-core 1.5.0.dev20250403060241__py3-none-any.whl → 1.5.0.dev20250403161251__py3-none-any.whl

cirq/ops/common_gates.py

@@ -177,7 +177,7 @@ class XPowGate(eigen_gate.EigenGate):
             return SingleQubitCliffordGate.X.on(*qubits)
         if self.exponent % 2 == 1.5:
             return SingleQubitCliffordGate.X_nsqrt.on(*qubits)
-        return NotImplemented
+        return NotImplemented  # pragma: no cover
 
     def _trace_distance_bound_(self) -> Optional[float]:
         if self._is_parameterized_() or self._dimension != 2:
@@ -259,7 +259,7 @@ class XPowGate(eigen_gate.EigenGate):
 
     def _pauli_expansion_(self) -> value.LinearDict[str]:
         if self._dimension != 2:
-            return NotImplemented
+            return NotImplemented  # pragma: no cover
         phase = 1j ** (2 * self._exponent * (self._global_shift + 0.5))
         lib = sympy if protocols.is_parameterized(self) else np
         angle = lib.pi * self._exponent / 2
@@ -451,7 +451,7 @@ class YPowGate(eigen_gate.EigenGate):
             return SingleQubitCliffordGate.Y.on(*qubits)
         if self.exponent % 2 == 1.5:
             return SingleQubitCliffordGate.Y_nsqrt.on(*qubits)
-        return NotImplemented
+        return NotImplemented  # pragma: no cover
 
     def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
         return [
@@ -656,7 +656,7 @@ class ZPowGate(eigen_gate.EigenGate):
             return SingleQubitCliffordGate.Z.on(*qubits)
         if self.exponent % 2 == 1.5:
             return SingleQubitCliffordGate.Z_nsqrt.on(*qubits)
-        return NotImplemented
+        return NotImplemented  # pragma: no cover
 
     def in_su2(self) -> 'Rz':
         """Returns an equal-up-global-phase gate from the group SU2."""
@@ -765,7 +765,7 @@ class ZPowGate(eigen_gate.EigenGate):
 
     def _pauli_expansion_(self) -> value.LinearDict[str]:
         if self._dimension != 2:
-            return NotImplemented
+            return NotImplemented  # pragma: no cover
         phase = 1j ** (2 * self._exponent * (self._global_shift + 0.5))
         lib = sympy if protocols.is_parameterized(self) else np
         angle = lib.pi * self._exponent / 2
@@ -982,7 +982,7 @@ class HPowGate(eigen_gate.EigenGate):
             return SingleQubitCliffordGate.H.on(*qubits)
         if self.exponent % 2 == 0:
             return []
-        return NotImplemented
+        return NotImplemented  # pragma: no cover
 
     def _apply_unitary_(self, args: 'protocols.ApplyUnitaryArgs') -> Optional[np.ndarray]:
         if self._exponent != 1:
@@ -1080,7 +1080,7 @@ class CZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
             return PauliInteractionGate.CZ.on(*qubits)
         if self.exponent % 2 == 0:
             return []
-        return NotImplemented
+        return NotImplemented  # pragma: no cover
 
     def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
         return [(0, np.diag([1, 1, 1, 0])), (1, np.diag([0, 0, 0, 1]))]
@@ -1275,7 +1275,7 @@ class CXPowGate(eigen_gate.EigenGate):
             return PauliInteractionGate.CNOT.on(*qubits)
         if self.exponent % 2 == 0:
             return []
-        return NotImplemented
+        return NotImplemented  # pragma: no cover
 
     def _decompose_(self, qubits):
         c, t = qubits

cirq/ops/common_gates_test.py

@@ -307,6 +307,11 @@ def test_h_str():
     assert str(cirq.H**0.5) == 'H**0.5'
 
 
+def test_phase_exponent():
+    assert cirq.XPowGate(exponent=0.5).phase_exponent == 0.0
+    assert cirq.YPowGate(exponent=0.5).phase_exponent == 0.5
+
+
 def test_x_act_on_tableau():
     with pytest.raises(TypeError, match="Failed to act"):
         cirq.act_on(cirq.X, ExampleSimulationState(), qubits=())

cirq/ops/control_values.py

@@ -275,7 +275,7 @@ class SumOfProducts(AbstractControlValues):
 
         if len(self._conjunctions) == 1:
             # Use a simpler diagram if there's only 1 term.
-            return protocols.CircuitDiagramInfo(
+            return protocols.CircuitDiagramInfo(  # pragma: no cover
                 wire_symbols=["@" if x == 1 else f"({x})" for x in self._conjunctions[0]]
             )
 

cirq/ops/controlled_gate.py

@@ -314,7 +314,7 @@ class ControlledGate(raw_types.Gate):
             return None
         u = protocols.unitary(self.sub_gate, default=None)
         if u is None:
-            return NotImplemented
+            return NotImplemented  # pragma: no cover
         angle_list = np.append(np.angle(np.linalg.eigvals(u)), 0)
         return protocols.trace_distance_from_angle_list(angle_list)
 

cirq/ops/controlled_operation.py

@@ -297,7 +297,7 @@ class ControlledOperation(raw_types.Operation):
             return None
         u = protocols.unitary(self.sub_operation, default=None)
         if u is None:
-            return NotImplemented
+            return NotImplemented  # pragma: no cover
         angle_list = np.append(np.angle(np.linalg.eigvals(u)), 0)
         return protocols.trace_distance_from_angle_list(angle_list)
 

cirq/ops/controlled_operation_test.py

@@ -159,7 +159,7 @@ def test_str():
             return ()
 
         def with_qubits(self, *new_qubits: cirq.Qid):
-            pass
+            return self
 
         def __str__(self):
             return "Op(q2)"
@@ -170,7 +170,11 @@ def test_str():
     assert str(cirq.ControlledOperation([c1, c2], SingleQubitOp())) == "CC(c1, c2, Op(q2))"
 
     assert (
-        str(cirq.ControlledOperation([c1, c2.with_dimension(3)], SingleQubitOp()))
+        str(
+            cirq.ControlledOperation(
+                [c1, c2.with_dimension(3)], SingleQubitOp().with_qubits(cirq.q(1))
+            )
+        )
         == "CC(c1, c2 (d=3), Op(q2))"
     )
 

cirq/ops/dense_pauli_string.py

@@ -627,7 +627,7 @@ def _attempt_value_to_pauli_index(v: 'cirq.Operation') -> Optional[Tuple[int, in
         return None
 
     if not isinstance(v.gate, pauli_gates.Pauli):
-        return None
+        return None  # pragma: no cover
 
     q = v.qubits[0]
     from cirq import devices

cirq/ops/eigen_gate.py

@@ -302,7 +302,7 @@ class EigenGate(raw_types.Gate):
     def __pow__(self, exponent: Union[float, sympy.Symbol]) -> 'EigenGate':
         new_exponent = protocols.mul(self._exponent, exponent, NotImplemented)
         if new_exponent is NotImplemented:
-            return NotImplemented
+            return NotImplemented  # pragma: no cover
         return self._with_exponent(exponent=new_exponent)
 
     @property

cirq/ops/fourier_transform.py

@@ -170,8 +170,6 @@ class PhaseGradientGate(raw_types.Gate):
         self, resolver: 'cirq.ParamResolver', recursive: bool
     ) -> 'PhaseGradientGate':
         new_exponent = cirq.resolve_parameters(self.exponent, resolver, recursive)
-        if new_exponent is self.exponent:
-            return self
         return PhaseGradientGate(num_qubits=self._num_qubits, exponent=new_exponent)
 
     def __str__(self) -> str:

cirq/ops/gate_operation.py

@@ -302,7 +302,7 @@ class GateOperation(raw_types.Operation):
     def _decompose_into_clifford_(self):
         sub = getattr(self.gate, '_decompose_into_clifford_with_qubits_', None)
         if sub is None:
-            return NotImplemented
+            return NotImplemented  # pragma: no cover
         return sub(self.qubits)
 
     def _trace_distance_bound_(self) -> float:

cirq/ops/gate_operation_test.py

@@ -454,6 +454,7 @@ def test_is_parameterized():
             return True
 
     q = cirq.LineQubit(0)
+    assert No1().num_qubits() == 1
     assert not cirq.is_parameterized(No1().on(q))
     assert not cirq.is_parameterized(No2().on(q))
     assert cirq.is_parameterized(Yes().on(q))

cirq/ops/gateset_test.py

@@ -443,3 +443,10 @@ def test_gateset_contains_with_tags():
     # Both tags to accept and tags to ignore
     assert op in cirq.Gateset(gf_accept, gf_ignore)
     assert op_with_tag in cirq.Gateset(gf_accept, gf_ignore)
+
+
+def test_gateset_contains_op_with_no_gate():
+    gf = cirq.GateFamily(cirq.ZPowGate)
+    op = cirq.X(cirq.q(1)).with_classical_controls('a')
+    assert op.gate is None
+    assert op not in gf

cirq/ops/greedy_qubit_manager_test.py

@@ -90,6 +90,11 @@ ancilla_1: ───X───X───
     )
 
 
+def test_empty_qubits():
+    qm = cirq.GreedyQubitManager(prefix="anc")
+    assert qm.qalloc(0) == []
+
+
 def test_greedy_qubit_manager_preserves_order():
     qm = cirq.GreedyQubitManager(prefix="anc")
     ancillae = [cirq.q(f"anc_{i}") for i in range(100)]

cirq/ops/kraus_channel_test.py

@@ -54,6 +54,7 @@ def test_kraus_channel_remap_keys():
     kc_x = cirq.KrausChannel.from_channel(dp, key='x')
     assert cirq.with_measurement_key_mapping(kc_x, {'a': 'b'}) is kc_x
     assert cirq.measurement_key_name(cirq.with_key_path(kc_x, ('path',))) == 'path:x'
+    assert cirq.measurement_key_name(cirq.with_key_path_prefix(kc_x, ('path',))) == 'path:x'
 
     kc_a = cirq.KrausChannel.from_channel(dp, key='a')
     kc_b = cirq.KrausChannel.from_channel(dp, key='b')

cirq/ops/mixed_unitary_channel_test.py

@@ -55,6 +55,7 @@ def test_matrix_mixture_remap_keys():
     mm_x = cirq.MixedUnitaryChannel.from_mixture(dp, key='x')
     assert cirq.with_measurement_key_mapping(mm_x, {'a': 'b'}) is mm_x
     assert cirq.measurement_key_name(cirq.with_key_path(mm_x, ('path',))) == 'path:x'
+    assert cirq.measurement_key_name(cirq.with_key_path_prefix(mm_x, ('path',))) == 'path:x'
 
     mm_a = cirq.MixedUnitaryChannel.from_mixture(dp, key='a')
     mm_b = cirq.MixedUnitaryChannel.from_mixture(dp, key='b')

cirq/ops/op_tree_test.py

@@ -135,6 +135,10 @@ def test_transform_leaves():
     # Just an item.
     assert move_tree_left_freeze(operations[0]) == expected[0]
 
+    # Just a moment
+    m = cirq.Moment(cirq.X(cirq.q(1)))
+    assert cirq.transform_op_tree(m, preserve_moments=True) is m
+
     # Flat list.
     assert move_tree_left_freeze(operations) == tuple(expected)
 

cirq/ops/pauli_measurement_gate_test.py

@@ -63,6 +63,7 @@ def test_measurement_eq():
     [
         (None, None, 'b'),
         (cirq.with_key_path, ('p', 'q'), 'p:q:a'),
+        (cirq.with_key_path_prefix, ('p', 'q'), 'p:q:a'),
         (cirq.with_measurement_key_mapping, {'a': 'b'}, 'b'),
     ],
 )

cirq/ops/pauli_string.py

@@ -311,7 +311,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
             )
 
         if isinstance(other, raw_types.Operation) and isinstance(other.gate, identity.IdentityGate):
-            return self
+            return self  # pragma: no cover
 
         # Note: PauliString case handled by __mul__.
         return NotImplemented
@@ -462,7 +462,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         fused = prefix + '*'.join(factors)
         if len(factors) > 1:
             return f'({fused})'
-        return fused
+        return fused  # pragma: no cover
 
     def __str__(self) -> str:
         ordered_qubits = sorted(self.qubits)
@@ -1646,88 +1646,11 @@ def _decompose_into_cliffords(op: 'cirq.Operation') -> List['cirq.Operation']:
     if decomposed is not None:
         return [out for sub_op in decomposed for out in _decompose_into_cliffords(sub_op)]
 
-    raise TypeError(
+    raise TypeError(  # pragma: no cover
         f'Operation is not a known Clifford and did not decompose into known Cliffords: {op!r}'
     )
 
 
-def _pass_operation_over(
-    pauli_map: Dict[TKey, pauli_gates.Pauli], op: 'cirq.Operation', after_to_before: bool = False
-) -> bool:
-    if isinstance(op, gate_operation.GateOperation):
-        gate = op.gate
-        if isinstance(gate, clifford_gate.SingleQubitCliffordGate):
-            return _pass_single_clifford_gate_over(
-                pauli_map, gate, cast(TKey, op.qubits[0]), after_to_before=after_to_before
-            )
-        if isinstance(gate, pauli_interaction_gate.PauliInteractionGate):
-            return _pass_pauli_interaction_gate_over(
-                pauli_map,
-                gate,
-                cast(TKey, op.qubits[0]),
-                cast(TKey, op.qubits[1]),
-                after_to_before=after_to_before,
-            )
-    raise NotImplementedError(f'Unsupported operation: {op!r}')
-
-
-def _pass_single_clifford_gate_over(
-    pauli_map: Dict[TKey, pauli_gates.Pauli],
-    gate: clifford_gate.SingleQubitCliffordGate,
-    qubit: TKey,
-    after_to_before: bool = False,
-) -> bool:
-    if qubit not in pauli_map:
-        return False  # pragma: no cover
-    if not after_to_before:
-        gate **= -1
-    pauli, inv = gate.pauli_tuple(pauli_map[qubit])
-    pauli_map[qubit] = pauli
-    return inv
-
-
-def _pass_pauli_interaction_gate_over(
-    pauli_map: Dict[TKey, pauli_gates.Pauli],
-    gate: pauli_interaction_gate.PauliInteractionGate,
-    qubit0: TKey,
-    qubit1: TKey,
-    after_to_before: bool = False,
-) -> bool:
-    def merge_and_kickback(
-        qubit: TKey,
-        pauli_left: Optional[pauli_gates.Pauli],
-        pauli_right: Optional[pauli_gates.Pauli],
-        inv: bool,
-    ) -> int:
-        assert pauli_left is not None or pauli_right is not None
-        if pauli_left is None or pauli_right is None:
-            pauli_map[qubit] = cast(pauli_gates.Pauli, pauli_left or pauli_right)
-            return 0
-        if pauli_left == pauli_right:
-            del pauli_map[qubit]
-            return 0
-
-        pauli_map[qubit] = pauli_left.third(pauli_right)
-        if (pauli_left < pauli_right) ^ after_to_before:
-            return int(inv) * 2 + 1
-
-        return int(inv) * 2 - 1
-
-    quarter_kickback = 0
-    if qubit0 in pauli_map and not protocols.commutes(pauli_map[qubit0], gate.pauli0):
-        quarter_kickback += merge_and_kickback(
-            qubit1, gate.pauli1, pauli_map.get(qubit1), gate.invert1
-        )
-    if qubit1 in pauli_map and not protocols.commutes(pauli_map[qubit1], gate.pauli1):
-        quarter_kickback += merge_and_kickback(
-            qubit0, pauli_map.get(qubit0), gate.pauli0, gate.invert0
-        )
-    assert (
-        quarter_kickback % 2 == 0
-    ), 'Impossible condition.  quarter_kickback is either incremented twice or never.'
-    return quarter_kickback % 4 == 2
-
-
 # Mypy has extreme difficulty with these constants for some reason.
 _i = cast(identity.IdentityGate, identity.I)  # type: ignore
 _x = cast(pauli_gates.Pauli, pauli_gates.X)  # type: ignore

cirq/ops/pauli_string_test.py

@@ -1889,6 +1889,48 @@ def test_mutable_pauli_string_inplace_conjugate_by():
     p2 = p.inplace_after(cirq.S(a))
     assert p2 is p and p == cirq.X(a)
 
+    # After sqrt-X and back.
+    p2 = p.inplace_before(cirq.X(a) ** 0.5)
+    assert p2 is p and p == cirq.X(a)
+    p2 = p.inplace_after(cirq.X(a) ** 0.5)
+    assert p2 is p and p == cirq.X(a)
+
+    # After sqrt-Y and back.
+    p2 = p.inplace_before(cirq.Y(a) ** 0.5)
+    assert p2 is p and p == cirq.Z(a)
+    p2 = p.inplace_after(cirq.Y(a) ** 0.5)
+    assert p2 is p and p == cirq.X(a)
+
+    # After inv-sqrt-Y and back.
+    p2 = p.inplace_before(cirq.Y(a) ** 1.5)
+    assert p2 is p and p == -cirq.Z(a)
+    p2 = p.inplace_after(cirq.Y(a) ** 1.5)
+    assert p2 is p and p == cirq.X(a)
+
+    # After X**0 and back.
+    p2 = p.inplace_before(cirq.X(a) ** 0)
+    assert p2 is p and p == cirq.X(a)
+    p2 = p.inplace_after(cirq.X(a) ** 0)
+    assert p2 is p and p == cirq.X(a)
+
+    # After Y**0 and back.
+    p2 = p.inplace_before(cirq.Y(a) ** 0)
+    assert p2 is p and p == cirq.X(a)
+    p2 = p.inplace_after(cirq.Y(a) ** 0)
+    assert p2 is p and p == cirq.X(a)
+
+    # After Z**0 and back.
+    p2 = p.inplace_before(cirq.Z(a) ** 0)
+    assert p2 is p and p == cirq.X(a)
+    p2 = p.inplace_after(cirq.Z(a) ** 0)
+    assert p2 is p and p == cirq.X(a)
+
+    # After H**0 and back.
+    p2 = p.inplace_before(cirq.H(a) ** 0)
+    assert p2 is p and p == cirq.X(a)
+    p2 = p.inplace_after(cirq.H(a) ** 0)
+    assert p2 is p and p == cirq.X(a)
+
     # After inverse S and back.
     p2 = p.inplace_after(cirq.S(a) ** -1)
     assert p2 is p and p == -cirq.Y(a)
@@ -1900,6 +1942,10 @@ def test_mutable_pauli_string_inplace_conjugate_by():
     assert p2 is p and p == cirq.X(a)
 
     # Two qubit operation.
+    p2 = p.inplace_after(cirq.CX(a, b) ** 0)
+    assert p2 is p and p == cirq.X(a)
+    p2 = p.inplace_after(cirq.CZ(a, b) ** 0)
+    assert p2 is p and p == cirq.X(a)
     p2 = p.inplace_after(cirq.CZ(a, b))
     assert p2 is p and p == cirq.X(a) * cirq.Z(b)
     p2 = p.inplace_after(cirq.CZ(a, c))

cirq/ops/phased_x_gate.py

@@ -116,7 +116,7 @@ class PhasedXPowGate(raw_types.Gate):
     def __pow__(self, exponent: Union[float, sympy.Expr]) -> 'PhasedXPowGate':
         new_exponent = protocols.mul(self._exponent, exponent, NotImplemented)
         if new_exponent is NotImplemented:
-            return NotImplemented
+            return NotImplemented  # pragma: no cover
         return PhasedXPowGate(
             phase_exponent=self._phase_exponent,
             exponent=new_exponent,

cirq/ops/random_gate_channel_test.py

@@ -150,12 +150,6 @@ def test_mixture():
     assert {p for p, _ in m} == {7 / 8, 1 / 32, 3 / 32}
 
 
-def assert_channel_sums_to_identity(val):
-    m = cirq.kraus(val)
-    s = sum(np.conj(e.T) @ e for e in m)
-    np.testing.assert_allclose(s, np.eye(np.prod(cirq.qid_shape(val), dtype=np.int64)), atol=1e-8)
-
-
 def test_channel():
     class NoDetailsGate(cirq.Gate):
         def num_qubits(self) -> int:

cirq/ops/raw_types.py

@@ -902,7 +902,7 @@ class TaggedOperation(Operation):
         sub = getattr(self.sub_operation, "_is_measurement_", None)
         if sub is not None:
             return sub()
-        return NotImplemented
+        return NotImplemented  # pragma: no cover
 
     @cached_method
     def _is_parameterized_(self) -> bool:

cirq/ops/raw_types_test.py

@@ -77,6 +77,13 @@ def test_wrapped_qid():
         'dimension': 3,
     }
 
+    assert not ValidQubit('zz') == 4
+    assert ValidQubit('zz') != 4
+    assert ValidQubit('zz') > ValidQubit('aa')
+    assert ValidQubit('zz') <= ValidQubit('zz')
+    assert ValidQubit('zz') >= ValidQubit('zz')
+    assert ValidQubit('zz') >= ValidQubit('aa')
+
 
 def test_qid_dimension():
     assert ValidQubit('a').dimension == 2
@@ -210,6 +217,21 @@ def test_default_validation_and_inverse():
     cirq.testing.assert_implements_consistent_protocols(i, local_vals={'TestGate': TestGate})
 
 
+def test_default_no_qubits():
+    class TestOp(cirq.Operation):
+        def with_qubits(self, *new_qubits):
+            raise NotImplementedError()
+
+        @property
+        def qubits(self):
+            pass
+
+    op = TestOp()
+    assert op.controlled_by(*[]) is op
+    op = TestOp().with_tags("abc")
+    assert op.classical_controls == frozenset()
+
+
 def test_default_inverse():
     class TestGate(cirq.Gate):
         def _num_qubits_(self):
@@ -357,7 +379,7 @@ def test_gate_shape_protocol():
 def test_operation_shape():
     class FixedQids(cirq.Operation):
         def with_qubits(self, *new_qids):
-            raise NotImplementedError  # pragma: no cover
+            raise NotImplementedError
 
     class QubitOp(FixedQids):
         @property
@@ -659,6 +681,9 @@ def test_tagged_operation_forwards_protocols():
     assert isinstance(controlled_y, cirq.Operation)
     assert not isinstance(controlled_y, cirq.TaggedOperation)
     classically_controlled_y = tagged_y.with_classical_controls("a")
+    assert classically_controlled_y.classical_controls == frozenset(
+        {cirq.KeyCondition(cirq.MeasurementKey(name='a'))}
+    )
     assert classically_controlled_y == y.with_classical_controls("a")
     assert isinstance(classically_controlled_y, cirq.Operation)
     assert not isinstance(classically_controlled_y, cirq.TaggedOperation)

cirq/protocols/decompose_protocol_test.py

@@ -358,7 +358,7 @@ class RecursiveDecompose(cirq.Gate):
 
     def _decompose_(self, qubits):
         if self.with_context:
-            assert False
+            assert False  # pragma: no cover
         else:
             return self._decompose_impl(qubits, self.mock_qm)
 

cirq/protocols/has_unitary_protocol_test.py

@@ -80,7 +80,8 @@ def test_via_apply_unitary():
 
     class No4:  # A non-operation non-gate.
         def _apply_unitary_(self, args):
-            assert False  # Because has_unitary doesn't understand how to call.
+            # Because has_unitary doesn't understand how to call.
+            assert False  # pragma: no cover
 
     class Yes1(EmptyOp):
         def _apply_unitary_(self, args):
@@ -155,13 +156,13 @@ def test_order():
             return True
 
         def _decompose_(self):
-            assert False
+            assert False  # pragma: no cover
 
         def _apply_unitary_(self, args):
-            assert False
+            assert False  # pragma: no cover
 
         def _unitary_(self):
-            assert False
+            assert False  # pragma: no cover
 
     class Yes2(EmptyOp):
         def _has_unitary_(self):
@@ -171,10 +172,10 @@ def test_order():
             return []
 
         def _apply_unitary_(self, args):
-            assert False
+            assert False  # pragma: no cover
 
         def _unitary_(self):
-            assert False
+            assert False  # pragma: no cover
 
     class Yes3(EmptyOp):
         def _has_unitary_(self):
@@ -187,7 +188,7 @@ def test_order():
             return args.target_tensor
 
         def _unitary_(self):
-            assert False
+            assert False  # pragma: no cover
 
     class Yes4(EmptyOp):
         def _has_unitary_(self):

cirq/protocols/json_serialization_test.py

@@ -84,20 +84,20 @@ def test_deprecated_cirq_type_in_json_dict():
         __module__ = 'test.noncirq.namespace'
 
         def __eq__(self, other):
-            return isinstance(other, HasOldJsonDict)
+            return isinstance(other, HasOldJsonDict)  # pragma: no cover
 
         def _json_dict_(self):
             return {'cirq_type': 'test.noncirq.namespace.HasOldJsonDict'}
 
         @classmethod
         def _from_json_dict_(cls, **kwargs):
-            return cls()
+            return cls()  # pragma: no cover
 
     with pytest.raises(ValueError, match='not a Cirq type'):
         _ = cirq.json_cirq_type(HasOldJsonDict)
 
     def custom_resolver(name):
-        if name == 'test.noncirq.namespace.HasOldJsonDict':
+        if name == 'test.noncirq.namespace.HasOldJsonDict':  # pragma: no cover
             return HasOldJsonDict
 
     test_resolvers = [custom_resolver] + cirq.DEFAULT_RESOLVERS
@@ -283,6 +283,7 @@ def test_builtins():
 def test_numpy():
     x = np.ones(1)[0]
 
+    assert_json_roundtrip_works(np.bool_(True))
     assert_json_roundtrip_works(x.astype(np.int8))
     assert_json_roundtrip_works(x.astype(np.int16))
     assert_json_roundtrip_works(x.astype(np.int32))
@@ -367,7 +368,7 @@ class SBKImpl(cirq.SerializableByKey):
 
     def __eq__(self, other):
         if not isinstance(other, SBKImpl):
-            return False
+            return False  # pragma: no cover
         return (
             self.name == other.name
             and self.data_list == other.data_list
@@ -542,7 +543,7 @@ def test_type_serialization(mod_spec: ModuleJsonTestSpec, cirq_obj_name: str, cl
         return pytest.xfail(reason="Not serializable (yet)")
 
     if cls is None:
-        pytest.skip(f'No serialization for None-mapped type: {cirq_obj_name}')
+        pytest.skip(f'No serialization for None-mapped type: {cirq_obj_name}')  # pragma: no cover
 
     try:
         typename = cirq.json_cirq_type(cls)
@@ -614,7 +615,7 @@ def _eval_repr_data_file(path: pathlib.Path, deprecation_deadline: Optional[str]
 
     for deprecation in TESTED_MODULES.values():
         if deprecation is not None and deprecation.old_name in content:
-            ctx_managers.append(deprecation.deprecation_assertion)
+            ctx_managers.append(deprecation.deprecation_assertion)  # pragma: no cover
 
     imports = {'cirq': cirq, 'pd': pd, 'sympy': sympy, 'np': np, 'datetime': datetime, 'nx': nx}
 

cirq/protocols/kraus_protocol.py

@@ -132,7 +132,7 @@ def kraus(
     """
     channel_getter = getattr(val, '_channel_', None)
     if channel_getter is not None:
-        warnings.warn(
+        warnings.warn(  # pragma: no cover
             '_channel_ is deprecated and will be removed in cirq 0.13, rename to _kraus_',
             DeprecationWarning,
         )
@@ -154,7 +154,7 @@ def kraus(
 
     channel_result = NotImplemented if channel_getter is None else channel_getter()
     if channel_result is not NotImplemented:
-        return tuple(channel_result)
+        return tuple(channel_result)  # pragma: no cover
 
     if default is not RaiseTypeErrorIfNotProvided:
         return default