cirq-core 1.4.0.dev20240529225110__py3-none-any.whl → 1.5.0__py3-none-any.whl

cirq/protocols/__init__.py

@@ -14,114 +14,166 @@
 
 """Protocols (structural subtyping) supported in Cirq."""
 
-from cirq.protocols.act_on_protocol import act_on, SupportsActOn, SupportsActOnQubits
+from cirq.protocols.act_on_protocol import (
+    act_on as act_on,
+    SupportsActOn as SupportsActOn,
+    SupportsActOnQubits as SupportsActOnQubits,
+)
+
 from cirq.protocols.apply_unitary_protocol import (
-    apply_unitaries,
-    apply_unitary,
-    ApplyUnitaryArgs,
-    SupportsConsistentApplyUnitary,
+    apply_unitaries as apply_unitaries,
+    apply_unitary as apply_unitary,
+    ApplyUnitaryArgs as ApplyUnitaryArgs,
+    SupportsConsistentApplyUnitary as SupportsConsistentApplyUnitary,
 )
+
 from cirq.protocols.apply_channel_protocol import (
-    apply_channel,
-    ApplyChannelArgs,
-    SupportsApplyChannel,
+    apply_channel as apply_channel,
+    ApplyChannelArgs as ApplyChannelArgs,
+    SupportsApplyChannel as SupportsApplyChannel,
 )
+
 from cirq.protocols.apply_mixture_protocol import (
-    apply_mixture,
-    ApplyMixtureArgs,
-    SupportsApplyMixture,
+    apply_mixture as apply_mixture,
+    ApplyMixtureArgs as ApplyMixtureArgs,
+    SupportsApplyMixture as SupportsApplyMixture,
 )
-from cirq.protocols.approximate_equality_protocol import approx_eq, SupportsApproximateEquality
-from cirq.protocols.kraus_protocol import kraus, has_kraus, SupportsKraus
-from cirq.protocols.commutes_protocol import commutes, definitely_commutes, SupportsCommutes
+
+from cirq.protocols.approximate_equality_protocol import (
+    approx_eq as approx_eq,
+    SupportsApproximateEquality as SupportsApproximateEquality,
+)
+
+from cirq.protocols.kraus_protocol import (
+    kraus as kraus,
+    has_kraus as has_kraus,
+    SupportsKraus as SupportsKraus,
+)
+
+from cirq.protocols.commutes_protocol import (
+    commutes as commutes,
+    definitely_commutes as definitely_commutes,
+    SupportsCommutes as SupportsCommutes,
+)
+
 from cirq.protocols.control_key_protocol import (
-    control_keys,
-    measurement_keys_touched,
-    SupportsControlKey,
+    control_keys as control_keys,
+    measurement_keys_touched as measurement_keys_touched,
+    SupportsControlKey as SupportsControlKey,
 )
+
 from cirq.protocols.circuit_diagram_info_protocol import (
-    circuit_diagram_info,
-    CircuitDiagramInfo,
-    CircuitDiagramInfoArgs,
-    LabelEntity,
-    SupportsCircuitDiagramInfo,
+    circuit_diagram_info as circuit_diagram_info,
+    CircuitDiagramInfo as CircuitDiagramInfo,
+    CircuitDiagramInfoArgs as CircuitDiagramInfoArgs,
+    LabelEntity as LabelEntity,
+    SupportsCircuitDiagramInfo as SupportsCircuitDiagramInfo,
 )
+
 from cirq.protocols.decompose_protocol import (
-    decompose,
-    decompose_once,
-    decompose_once_with_qubits,
-    DecompositionContext,
-    SupportsDecompose,
-    SupportsDecomposeWithQubits,
+    decompose as decompose,
+    decompose_once as decompose_once,
+    decompose_once_with_qubits as decompose_once_with_qubits,
+    DecompositionContext as DecompositionContext,
+    SupportsDecompose as SupportsDecompose,
+    SupportsDecomposeWithQubits as SupportsDecomposeWithQubits,
 )
+
 from cirq.protocols.equal_up_to_global_phase_protocol import (
-    equal_up_to_global_phase,
-    SupportsEqualUpToGlobalPhase,
+    equal_up_to_global_phase as equal_up_to_global_phase,
+    SupportsEqualUpToGlobalPhase as SupportsEqualUpToGlobalPhase,
+)
+
+from cirq.protocols.has_stabilizer_effect_protocol import (
+    has_stabilizer_effect as has_stabilizer_effect,
+)
+
+from cirq.protocols.has_unitary_protocol import (
+    has_unitary as has_unitary,
+    SupportsExplicitHasUnitary as SupportsExplicitHasUnitary,
 )
-from cirq.protocols.has_stabilizer_effect_protocol import has_stabilizer_effect
-from cirq.protocols.has_unitary_protocol import has_unitary, SupportsExplicitHasUnitary
-from cirq.protocols.inverse_protocol import inverse
+
+from cirq.protocols.inverse_protocol import inverse as inverse
+
 from cirq.protocols.json_serialization import (
-    cirq_type_from_json,
-    DEFAULT_RESOLVERS,
-    HasJSONNamespace,
-    JsonResolver,
-    json_cirq_type,
-    json_namespace,
-    to_json_gzip,
-    read_json_gzip,
-    to_json,
-    read_json,
-    obj_to_dict_helper,
-    dataclass_json_dict,
-    SerializableByKey,
-    SupportsJSON,
+    cirq_type_from_json as cirq_type_from_json,
+    DEFAULT_RESOLVERS as DEFAULT_RESOLVERS,
+    HasJSONNamespace as HasJSONNamespace,
+    JsonResolver as JsonResolver,
+    json_cirq_type as json_cirq_type,
+    json_namespace as json_namespace,
+    to_json_gzip as to_json_gzip,
+    read_json_gzip as read_json_gzip,
+    to_json as to_json,
+    read_json as read_json,
+    obj_to_dict_helper as obj_to_dict_helper,
+    dataclass_json_dict as dataclass_json_dict,
+    SerializableByKey as SerializableByKey,
+    SupportsJSON as SupportsJSON,
 )
+
 from cirq.protocols.measurement_key_protocol import (
-    is_measurement,
-    measurement_key_name,
-    measurement_key_obj,
-    measurement_key_names,
-    measurement_key_objs,
-    with_key_path,
-    with_key_path_prefix,
-    with_measurement_key_mapping,
-    with_rescoped_keys,
-    SupportsMeasurementKey,
-)
-from cirq.protocols.mixture_protocol import has_mixture, mixture, SupportsMixture, validate_mixture
-from cirq.protocols.mul_protocol import mul
-from cirq.protocols.pauli_expansion_protocol import pauli_expansion, SupportsPauliExpansion
+    is_measurement as is_measurement,
+    measurement_key_name as measurement_key_name,
+    measurement_key_obj as measurement_key_obj,
+    measurement_key_names as measurement_key_names,
+    measurement_key_objs as measurement_key_objs,
+    with_key_path as with_key_path,
+    with_key_path_prefix as with_key_path_prefix,
+    with_measurement_key_mapping as with_measurement_key_mapping,
+    with_rescoped_keys as with_rescoped_keys,
+    SupportsMeasurementKey as SupportsMeasurementKey,
+)
+
+from cirq.protocols.mixture_protocol import (
+    has_mixture as has_mixture,
+    mixture as mixture,
+    SupportsMixture as SupportsMixture,
+    validate_mixture as validate_mixture,
+)
+
+from cirq.protocols.mul_protocol import mul as mul
+
+from cirq.protocols.pauli_expansion_protocol import (
+    pauli_expansion as pauli_expansion,
+    SupportsPauliExpansion as SupportsPauliExpansion,
+)
 
 # pylint: disable=redefined-builtin
-from cirq.protocols.pow_protocol import pow
+from cirq.protocols.pow_protocol import pow as pow
 
 # pylint: enable=redefined-builtin
+
 from cirq.protocols.qasm import (
-    qasm,
-    QasmArgs,
-    SupportsQasm,
-    SupportsQasmWithArgs,
-    SupportsQasmWithArgsAndQubits,
+    qasm as qasm,
+    QasmArgs as QasmArgs,
+    SupportsQasm as SupportsQasm,
+    SupportsQasmWithArgs as SupportsQasmWithArgs,
+    SupportsQasmWithArgsAndQubits as SupportsQasmWithArgsAndQubits,
 )
+
 from cirq.protocols.trace_distance_bound import (
-    SupportsTraceDistanceBound,
-    trace_distance_bound,
-    trace_distance_from_angle_list,
+    SupportsTraceDistanceBound as SupportsTraceDistanceBound,
+    trace_distance_bound as trace_distance_bound,
+    trace_distance_from_angle_list as trace_distance_from_angle_list,
 )
+
 from cirq.protocols.resolve_parameters import (
-    is_parameterized,
-    parameter_names,
-    parameter_symbols,
-    resolve_parameters,
-    resolve_parameters_once,
-    SupportsParameterization,
-)
-from cirq.protocols.phase_protocol import phase_by, SupportsPhase
+    is_parameterized as is_parameterized,
+    parameter_names as parameter_names,
+    parameter_symbols as parameter_symbols,
+    resolve_parameters as resolve_parameters,
+    resolve_parameters_once as resolve_parameters_once,
+    SupportsParameterization as SupportsParameterization,
+)
+
+from cirq.protocols.phase_protocol import phase_by as phase_by, SupportsPhase as SupportsPhase
+
 from cirq.protocols.qid_shape_protocol import (
-    num_qubits,
-    qid_shape,
-    SupportsExplicitQidShape,
-    SupportsExplicitNumQubits,
+    num_qubits as num_qubits,
+    qid_shape as qid_shape,
+    SupportsExplicitQidShape as SupportsExplicitQidShape,
+    SupportsExplicitNumQubits as SupportsExplicitNumQubits,
 )
-from cirq.protocols.unitary_protocol import SupportsUnitary, unitary
+
+from cirq.protocols.unitary_protocol import SupportsUnitary as SupportsUnitary, unitary as unitary

cirq/protocols/act_on_protocol.py

@@ -12,13 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from types import NotImplementedType
 from typing import Any, Optional, Sequence, TYPE_CHECKING, Union
 
 from typing_extensions import Protocol
 
 from cirq import ops
 from cirq._doc import doc_private
-from cirq.type_workarounds import NotImplementedType
 
 if TYPE_CHECKING:
     import cirq

cirq/protocols/act_on_protocol_test.py

@@ -12,10 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from typing import Any, Sequence, Tuple
-from typing_extensions import Self
 
 import numpy as np
 import pytest
+from typing_extensions import Self
 
 import cirq
 

cirq/protocols/apply_channel_protocol.py

@@ -14,17 +14,17 @@
 
 """A protocol for implementing high performance channel evolutions."""
 
-from typing import Any, Iterable, Optional, Sequence, TypeVar, Tuple, Union
+from types import NotImplementedType
+from typing import Any, Iterable, Optional, Sequence, Tuple, TypeVar, Union
 
 import numpy as np
 from typing_extensions import Protocol
 
 from cirq import linalg
 from cirq._doc import doc_private
+from cirq.protocols import qid_shape_protocol
 from cirq.protocols.apply_unitary_protocol import apply_unitary, ApplyUnitaryArgs
 from cirq.protocols.kraus_protocol import kraus
-from cirq.protocols import qid_shape_protocol
-from cirq.type_workarounds import NotImplementedType
 
 # This is a special indicator value used by the apply_channel method
 # to determine whether or not the caller provided a 'default' argument. It must

cirq/protocols/apply_mixture_protocol.py

@@ -14,6 +14,7 @@
 
 """A protocol for implementing high performance mixture evolutions."""
 
+from types import NotImplementedType
 from typing import Any, cast, Iterable, Optional, Tuple, TypeVar, Union
 
 import numpy as np
@@ -21,11 +22,8 @@ from typing_extensions import Protocol
 
 from cirq import linalg
 from cirq._doc import doc_private
-from cirq.protocols.apply_unitary_protocol import apply_unitary, ApplyUnitaryArgs
-
-from cirq.protocols.mixture_protocol import mixture
 from cirq.protocols import qid_shape_protocol
-from cirq.type_workarounds import NotImplementedType
+from cirq.protocols.apply_unitary_protocol import apply_unitary, ApplyUnitaryArgs
 
 # This is a special indicator value used by the apply_mixture method
 # to determine whether or not the caller provided a 'default' argument. It must
@@ -261,9 +259,9 @@ def apply_mixture(
         return result
 
     # Fallback to using the object's `_mixture_` matrices. (STEP C)
-    prob_mix = mixture(val, None)
-    if prob_mix is not None:
-        return _mixture_strat(prob_mix, args, is_density_matrix)
+    result = _apply_mixture_from_mixture_strat(val, args, is_density_matrix)
+    if result is not None:
+        return result
 
     # Don't know how to apply mixture. Fallback to specified default behavior.
     # (STEP D)
@@ -360,11 +358,19 @@ def _apply_unitary_from_matrix_strat(
     return args.target_tensor
 
 
-def _mixture_strat(val: Any, args: 'ApplyMixtureArgs', is_density_matrix: bool) -> np.ndarray:
+def _apply_mixture_from_mixture_strat(
+    val: Any, args: 'ApplyMixtureArgs', is_density_matrix: bool
+) -> Optional[np.ndarray]:
     """Attempt to use unitary matrices in _mixture_ and return the result."""
+    method = getattr(val, '_mixture_', None)
+    if method is None:
+        return None
+    prob_mix = method()
+    if prob_mix is NotImplemented or prob_mix is None:
+        return None
     args.out_buffer[:] = 0
     np.copyto(dst=args.auxiliary_buffer1, src=args.target_tensor)
-    for prob, op in val:
+    for prob, op in prob_mix:
         np.copyto(dst=args.target_tensor, src=args.auxiliary_buffer1)
         right_result = _apply_unitary_strat(op, args, is_density_matrix)
         if right_result is None:

cirq/protocols/apply_mixture_protocol_test.py

@@ -237,6 +237,17 @@ def test_apply_mixture_no_protocols_implemented():
         assert_apply_mixture_returns(NoProtocols(), rho, left_axes=[1], right_axes=[1])
 
 
+def test_apply_mixture_mixture_returns_not_implemented():
+    class NoMixture:
+        def _mixture_(self):
+            return NotImplemented
+
+    rho = np.ones((2, 2, 2, 2), dtype=np.complex128)
+
+    with pytest.raises(TypeError, match='has no'):
+        assert_apply_mixture_returns(NoMixture(), rho, left_axes=[1], right_axes=[1])
+
+
 def test_apply_mixture_no_protocols_implemented_default():
     class NoProtocols:
         pass

cirq/protocols/apply_unitary_protocol.py

@@ -15,6 +15,7 @@
 """A protocol for implementing high performance unitary left-multiplies."""
 
 import warnings
+from types import NotImplementedType
 from typing import Any, cast, Iterable, Optional, Sequence, Tuple, TYPE_CHECKING, TypeVar, Union
 
 import numpy as np
@@ -24,7 +25,6 @@ from cirq import linalg, qis
 from cirq._doc import doc_private
 from cirq.protocols import qid_shape_protocol
 from cirq.protocols.decompose_protocol import _try_decompose_into_operations_and_qubits
-from cirq.type_workarounds import NotImplementedType
 
 if TYPE_CHECKING:
     import cirq
@@ -390,7 +390,7 @@ def apply_unitary(
     # Try each strategy, stopping if one works.
     # Also catch downcasting warnings and throw an error: #2041
     with warnings.catch_warnings():
-        warnings.filterwarnings(action="error", category=np.ComplexWarning)
+        warnings.filterwarnings(action="error", category=np.exceptions.ComplexWarning)
         for strat in strats:
             result = strat(unitary_value, args)
             if result is None:

cirq/protocols/apply_unitary_protocol_test.py

@@ -714,7 +714,8 @@ def test_cast_to_complex():
     )
 
     with pytest.raises(
-        np.ComplexWarning, match='Casting complex values to real discards the imaginary part'
+        np.exceptions.ComplexWarning,
+        match='Casting complex values to real discards the imaginary part',
     ):
         cirq.apply_unitary(y0, args)
 

cirq/protocols/approximate_equality_protocol.py

@@ -12,14 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Union, Iterable
-from fractions import Fraction
+import numbers
 from decimal import Decimal
+from fractions import Fraction
+from typing import Any, Iterable
 
-import numbers
 import numpy as np
 import sympy
-
 from typing_extensions import Protocol
 
 from cirq._doc import doc_private
@@ -29,7 +28,7 @@ class SupportsApproximateEquality(Protocol):
     """Object which can be compared approximately."""
 
     @doc_private
-    def _approx_eq_(self, other: Any, *, atol: Union[int, float]) -> bool:
+    def _approx_eq_(self, other: Any, *, atol: float) -> bool:
         """Approximate comparator.
 
         Types implementing this protocol define their own logic for approximate
@@ -47,7 +46,7 @@ class SupportsApproximateEquality(Protocol):
         """
 
 
-def approx_eq(val: Any, other: Any, *, atol: Union[int, float] = 1e-8) -> bool:
+def approx_eq(val: Any, other: Any, *, atol: float = 1e-8) -> bool:
     """Approximately compares two objects.
 
     If `val` implements SupportsApproxEquality protocol then it is invoked and
@@ -120,7 +119,7 @@ def approx_eq(val: Any, other: Any, *, atol: Union[int, float] = 1e-8) -> bool:
     return val == other
 
 
-def _approx_eq_iterables(val: Iterable, other: Iterable, *, atol: Union[int, float]) -> bool:
+def _approx_eq_iterables(val: Iterable, other: Iterable, *, atol: float) -> bool:
     """Iterates over arguments and calls approx_eq recursively.
 
     Types of `val` and `other` does not necessarily needs to match each other.
@@ -161,7 +160,7 @@ def _approx_eq_iterables(val: Iterable, other: Iterable, *, atol: Union[int, flo
     return True
 
 
-def _isclose(a: Any, b: Any, *, atol: Union[int, float]) -> bool:
+def _isclose(a: Any, b: Any, *, atol: float) -> bool:
     """Convenience wrapper around np.isclose."""
 
     # support casting some standard numeric types

cirq/protocols/approximate_equality_protocol_test.py

@@ -12,12 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from fractions import Fraction
 from decimal import Decimal
+from fractions import Fraction
 from numbers import Number
+
 import numpy as np
 import pytest
 import sympy
+
 import cirq
 
 

cirq/protocols/circuit_diagram_info_protocol.py

@@ -16,15 +16,15 @@ import re
 from fractions import Fraction
 from typing import (
     Any,
-    TYPE_CHECKING,
-    Optional,
-    Union,
-    TypeVar,
     Dict,
-    overload,
     Iterable,
     List,
+    Optional,
+    overload,
     Sequence,
+    TYPE_CHECKING,
+    TypeVar,
+    Union,
 )
 
 import numpy as np
@@ -277,6 +277,8 @@ class CircuitDiagramInfoArgs:
         if self.precision is not None and not isinstance(radians, sympy.Basic):
             quantity = self.format_real(radians / np.pi)
             return quantity + unit
+        if isinstance(radians, np.number):
+            return str(radians)
         return repr(radians)
 
     def copy(self):
@@ -340,7 +342,7 @@ def _op_info_with_fallback(
     rows: List[LabelEntity] = list(op.qubits)
     if args.label_map is not None:
         rows += protocols.measurement_keys_touched(op) & args.label_map.keys()
-    if info is not None:
+    if info is not None and info.wire_symbols:
         if max(1, len(rows)) != len(info.wire_symbols):
             raise ValueError(f'Wanted diagram info from {op!r} for {rows!r}) but got {info!r}')
         return info

cirq/protocols/circuit_diagram_info_protocol_test.py

@@ -208,6 +208,9 @@ def test_format_real():
     assert args.format_real(sympy.Symbol('t')) == 't'
     assert args.format_real(sympy.Symbol('t') * 2 + 1) == '2*t + 1'
 
+    assert args.format_real(np.float64(1.1)) == '1.1'
+    assert args.format_real(np.int32(1)) == '1'
+
     args.precision = None
     assert args.format_real(1) == '1'
     assert args.format_real(1.1) == '1.1'
@@ -252,6 +255,7 @@ def test_format_radians_without_precision():
     assert args.format_radians(-np.pi) == '-pi'
     assert args.format_radians(1.1) == '1.1'
     assert args.format_radians(1.234567) == '1.234567'
+    assert args.format_radians(np.float32(1.234567)) == '1.234567'
     assert args.format_radians(1 / 7) == repr(1 / 7)
     assert args.format_radians(sympy.Symbol('t')) == 't'
     assert args.format_radians(sympy.Symbol('t') * 2 + 1) == '2*t + 1'
@@ -261,6 +265,7 @@ def test_format_radians_without_precision():
     assert args.format_radians(-np.pi) == '-π'
     assert args.format_radians(1.1) == '1.1'
     assert args.format_radians(1.234567) == '1.234567'
+    assert args.format_radians(np.float32(1.234567)) == '1.234567'
     assert args.format_radians(1 / 7) == repr(1 / 7)
     assert args.format_radians(sympy.Symbol('t')) == 't'
     assert args.format_radians(sympy.Symbol('t') * 2 + 1) == '2*t + 1'

cirq/protocols/commutes_protocol.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 """Protocol for determining commutativity."""
 
+from types import NotImplementedType
 from typing import Any, overload, TypeVar, Union
 
 import numpy as np
@@ -20,7 +21,6 @@ from typing_extensions import Protocol
 
 from cirq import linalg
 from cirq._doc import doc_private
-from cirq.type_workarounds import NotImplementedType
 
 # This is a special indicator value used by the unitary method to determine
 # whether or not the caller provided a 'default' argument.
@@ -74,17 +74,17 @@ class SupportsCommutes(Protocol):
 
 
 @overload
-def commutes(v1: Any, v2: Any, *, atol: Union[int, float] = 1e-8) -> bool: ...
+def commutes(v1: Any, v2: Any, *, atol: float = 1e-8) -> bool: ...
 
 
 @overload
 def commutes(
-    v1: Any, v2: Any, *, atol: Union[int, float] = 1e-8, default: TDefault
+    v1: Any, v2: Any, *, atol: float = 1e-8, default: TDefault
 ) -> Union[bool, TDefault]: ...
 
 
 def commutes(
-    v1: Any, v2: Any, *, atol: Union[int, float] = 1e-8, default: Any = RaiseTypeErrorIfNotProvided
+    v1: Any, v2: Any, *, atol: float = 1e-8, default: Any = RaiseTypeErrorIfNotProvided
 ) -> Any:
     """Determines whether two values commute.
 
@@ -147,7 +147,7 @@ def commutes(
     )
 
 
-def definitely_commutes(v1: Any, v2: Any, *, atol: Union[int, float] = 1e-8) -> bool:
+def definitely_commutes(v1: Any, v2: Any, *, atol: float = 1e-8) -> bool:
     """Determines whether two values definitely commute.
 
     Returns:
@@ -158,7 +158,7 @@ def definitely_commutes(v1: Any, v2: Any, *, atol: Union[int, float] = 1e-8) ->
 
 
 def _strat_commutes_from_commutes(
-    v1: Any, v2: Any, *, atol: Union[int, float] = 1e-8
+    v1: Any, v2: Any, *, atol: float = 1e-8
 ) -> Union[bool, NotImplementedType, None]:
     """Attempts to determine commutativity via the objects' _commutes_
     method."""

cirq/protocols/control_key_protocol.py

@@ -13,13 +13,13 @@
 # limitations under the License.
 """Protocol for object that have control keys."""
 
+from types import NotImplementedType
 from typing import Any, FrozenSet, TYPE_CHECKING, Union
 
 from typing_extensions import Protocol
 
 from cirq._doc import doc_private
 from cirq.protocols import measurement_key_protocol
-from cirq.type_workarounds import NotImplementedType
 
 if TYPE_CHECKING:
     import cirq

cirq/protocols/decompose_protocol.py

@@ -11,12 +11,12 @@
 # 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.
-import itertools
 import dataclasses
 import inspect
+import itertools
 from collections import defaultdict
+from types import NotImplementedType
 from typing import (
-    TYPE_CHECKING,
     Any,
     Callable,
     Dict,
@@ -27,17 +27,16 @@ from typing import (
     overload,
     Sequence,
     Tuple,
+    TYPE_CHECKING,
     TypeVar,
     Union,
 )
-from typing_extensions import runtime_checkable
 
-from typing_extensions import Protocol
+from typing_extensions import Protocol, runtime_checkable
 
 from cirq import devices, ops
 from cirq._doc import doc_private
 from cirq.protocols import qid_shape_protocol
-from cirq.type_workarounds import NotImplementedType
 
 if TYPE_CHECKING:
     import cirq

cirq/protocols/decompose_protocol_test.py

@@ -14,6 +14,7 @@
 import itertools
 from typing import Optional
 from unittest import mock
+
 import pytest
 
 import cirq
@@ -357,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)