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

cirq/protocols/circuit_diagram_info_protocol_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 numpy as np
 import pytest
 import sympy
@@ -18,7 +21,11 @@ import sympy
 import cirq
 
 
-def test_circuit_diagram_info_value_wrapping():
+class CustomTag:
+    pass
+
+
+def test_circuit_diagram_info_value_wrapping() -> None:
     single_info = cirq.CircuitDiagramInfo(('Single',))
 
     class ReturnInfo:
@@ -67,20 +74,20 @@ def test_circuit_diagram_info_value_wrapping():
     )
 
 
-def test_circuit_diagram_info_init():
+def test_circuit_diagram_info_init() -> None:
     assert cirq.CircuitDiagramInfo(['a', 'b']).wire_symbols == ('a', 'b')
 
 
-def test_circuit_diagram_info_validate():
+def test_circuit_diagram_info_validate() -> None:
     with pytest.raises(ValueError):
         _ = cirq.CircuitDiagramInfo('X')
 
 
-def test_circuit_diagram_info_repr():
+def test_circuit_diagram_info_repr() -> None:
     cirq.testing.assert_equivalent_repr(cirq.CircuitDiagramInfo(('X', 'Y'), 2))
 
 
-def test_circuit_diagram_info_eq():
+def test_circuit_diagram_info_eq() -> None:
     eq = cirq.testing.EqualsTester()
     eq.make_equality_group(lambda: cirq.CircuitDiagramInfo(('X',)))
     eq.add_equality_group(
@@ -92,7 +99,7 @@ def test_circuit_diagram_info_eq():
     eq.add_equality_group(cirq.CircuitDiagramInfo(('Z',), 3, auto_exponent_parens=False))
 
 
-def test_circuit_diagram_info_pass_fail():
+def test_circuit_diagram_info_pass_fail() -> None:
     class C:
         pass
 
@@ -115,7 +122,14 @@ def test_circuit_diagram_info_pass_fail():
     assert cirq.circuit_diagram_info(E()) == cirq.CircuitDiagramInfo(('X',))
 
 
-def test_circuit_diagram_info_args_eq():
+def test_controlled_1x1_matrixgate_diagram_error() -> None:
+    q = cirq.LineQubit(0)
+    g = cirq.MatrixGate(np.array([[1j]])).controlled()
+    c = cirq.Circuit(g(q))
+    assert str(c) == "0: ───C[[0.+1.j]]───"
+
+
+def test_circuit_diagram_info_args_eq() -> None:
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(cirq.CircuitDiagramInfoArgs.UNINFORMED_DEFAULT)
     eq.add_equality_group(
@@ -164,6 +178,26 @@ def test_circuit_diagram_info_args_eq():
             include_tags=False,
         )
     )
+    eq.add_equality_group(
+        cirq.CircuitDiagramInfoArgs(
+            known_qubits=cirq.LineQubit.range(2),
+            known_qubit_count=2,
+            use_unicode_characters=False,
+            precision=None,
+            label_map=None,
+            include_tags={str},
+        )
+    )
+    eq.add_equality_group(
+        cirq.CircuitDiagramInfoArgs(
+            known_qubits=cirq.LineQubit.range(2),
+            known_qubit_count=2,
+            use_unicode_characters=False,
+            precision=None,
+            label_map=None,
+            include_tags={CustomTag},
+        )
+    )
     eq.add_equality_group(
         cirq.CircuitDiagramInfoArgs(
             known_qubits=cirq.LineQubit.range(2),
@@ -185,7 +219,7 @@ def test_circuit_diagram_info_args_eq():
     )
 
 
-def test_circuit_diagram_info_args_repr():
+def test_circuit_diagram_info_args_repr() -> None:
     cirq.testing.assert_equivalent_repr(
         cirq.CircuitDiagramInfoArgs(
             known_qubits=cirq.LineQubit.range(2),
@@ -198,8 +232,32 @@ def test_circuit_diagram_info_args_repr():
         )
     )
 
+    cirq.testing.assert_equivalent_repr(
+        cirq.CircuitDiagramInfoArgs(
+            known_qubits=cirq.LineQubit.range(1),
+            known_qubit_count=1,
+            use_unicode_characters=False,
+            precision=None,
+            label_map=None,
+            include_tags={str},
+            transpose=False,
+        )
+    )
+
+    cirq.testing.assert_equivalent_repr(
+        cirq.CircuitDiagramInfoArgs(
+            known_qubits=cirq.LineQubit.range(1),
+            known_qubit_count=1,
+            use_unicode_characters=False,
+            precision=None,
+            label_map=None,
+            include_tags={CustomTag},
+            transpose=False,
+        )
+    )
+
 
-def test_format_real():
+def test_format_real() -> None:
     args = cirq.CircuitDiagramInfoArgs.UNINFORMED_DEFAULT.copy()
     assert args.format_real(1) == '1'
     assert args.format_real(1.1) == '1.1'
@@ -220,7 +278,7 @@ def test_format_real():
     assert args.format_real(sympy.Symbol('t') * 2 + 1) == '2*t + 1'
 
 
-def test_format_complex():
+def test_format_complex() -> None:
     args = cirq.CircuitDiagramInfoArgs.UNINFORMED_DEFAULT.copy()
     assert args.format_complex(1) == '1+0i'
     assert args.format_complex(1.1) == '1.1+0i'
@@ -243,7 +301,7 @@ def test_format_complex():
     assert args.format_complex(sympy.Symbol('t') * 2 + 1) == '2*t + 1'
 
 
-def test_format_radians_without_precision():
+def test_format_radians_without_precision() -> None:
     args = cirq.CircuitDiagramInfoArgs(
         known_qubits=None,
         known_qubit_count=None,
@@ -271,7 +329,7 @@ def test_format_radians_without_precision():
     assert args.format_radians(sympy.Symbol('t') * 2 + 1) == '2*t + 1'
 
 
-def test_format_radians_with_precision():
+def test_format_radians_with_precision() -> None:
     args = cirq.CircuitDiagramInfoArgs(
         known_qubits=None,
         known_qubit_count=None,

cirq/protocols/commutes_protocol.py

@@ -11,10 +11,13 @@
 # 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.
+
 """Protocol for determining commutativity."""
 
+from __future__ import annotations
+
 from types import NotImplementedType
-from typing import Any, overload, TypeVar, Union
+from typing import Any, overload, TypeVar
 
 import numpy as np
 from typing_extensions import Protocol
@@ -35,7 +38,7 @@ class SupportsCommutes(Protocol):
     """An object that can determine commutation relationships vs others."""
 
     @doc_private
-    def _commutes_(self, other: Any, *, atol: float) -> Union[None, bool, NotImplementedType]:
+    def _commutes_(self, other: Any, *, atol: float) -> None | bool | NotImplementedType:
         r"""Determines if this object commutes with the other object.
 
         Can return None to indicate the commutation relationship is
@@ -78,9 +81,7 @@ def commutes(v1: Any, v2: Any, *, atol: float = 1e-8) -> bool: ...
 
 
 @overload
-def commutes(
-    v1: Any, v2: Any, *, atol: float = 1e-8, default: TDefault
-) -> Union[bool, TDefault]: ...
+def commutes(v1: Any, v2: Any, *, atol: float = 1e-8, default: TDefault) -> bool | TDefault: ...
 
 
 def commutes(
@@ -159,7 +160,7 @@ def definitely_commutes(v1: Any, v2: Any, *, atol: float = 1e-8) -> bool:
 
 def _strat_commutes_from_commutes(
     v1: Any, v2: Any, *, atol: float = 1e-8
-) -> Union[bool, NotImplementedType, None]:
+) -> bool | NotImplementedType | None:
     """Attempts to determine commutativity via the objects' _commutes_
     method."""
 
@@ -176,7 +177,7 @@ def _strat_commutes_from_commutes(
 
 def _strat_commutes_from_matrix(
     v1: Any, v2: Any, *, atol: float
-) -> Union[bool, NotImplementedType, None]:
+) -> bool | NotImplementedType | None:
     """Attempts to determine commutativity of matrices."""
     if not isinstance(v1, np.ndarray) or not isinstance(v2, np.ndarray):
         return NotImplemented

cirq/protocols/commutes_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
 import sympy

cirq/protocols/control_key_protocol.py

@@ -13,8 +13,10 @@
 # limitations under the License.
 """Protocol for object that have control keys."""
 
+from __future__ import annotations
+
 from types import NotImplementedType
-from typing import Any, FrozenSet, TYPE_CHECKING, Union
+from typing import Any, TYPE_CHECKING
 
 from typing_extensions import Protocol
 
@@ -35,7 +37,7 @@ class SupportsControlKey(Protocol):
     """
 
     @doc_private
-    def _control_keys_(self) -> Union[FrozenSet['cirq.MeasurementKey'], NotImplementedType, None]:
+    def _control_keys_(self) -> frozenset[cirq.MeasurementKey] | NotImplementedType | None:
         """Return the keys for controls referenced by the receiving object.
 
         Returns:
@@ -44,7 +46,7 @@ class SupportsControlKey(Protocol):
         """
 
 
-def control_keys(val: Any) -> FrozenSet['cirq.MeasurementKey']:
+def control_keys(val: Any) -> frozenset[cirq.MeasurementKey]:
     """Gets the keys that the value is classically controlled by.
 
     Args:
@@ -62,7 +64,7 @@ def control_keys(val: Any) -> FrozenSet['cirq.MeasurementKey']:
     return frozenset()
 
 
-def measurement_keys_touched(val: Any) -> FrozenSet['cirq.MeasurementKey']:
+def measurement_keys_touched(val: Any) -> frozenset[cirq.MeasurementKey]:
     """Returns all the measurement keys used by the value.
 
     This would be the case if the value is or contains a measurement gate, or

cirq/protocols/control_key_protocol_test.py

@@ -12,10 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import cirq
 
 
-def test_control_key():
+def test_control_key() -> None:
     class Named:
         def _control_keys_(self):
             return frozenset([cirq.MeasurementKey('key')])

cirq/protocols/decompose_protocol.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 dataclasses
 import inspect
 import itertools
@@ -19,14 +22,10 @@ from types import NotImplementedType
 from typing import (
     Any,
     Callable,
-    Dict,
     Iterable,
     Iterator,
-    List,
-    Optional,
     overload,
     Sequence,
-    Tuple,
     TYPE_CHECKING,
     TypeVar,
     Union,
@@ -55,11 +54,11 @@ _CONTEXT_COUNTER = itertools.count()  # Use _reset_context_counter() to reset th
 @runtime_checkable
 class OpDecomposerWithContext(Protocol):
     def __call__(
-        self, __op: 'cirq.Operation', *, context: Optional['cirq.DecompositionContext'] = None
+        self, __op: cirq.Operation, *, context: cirq.DecompositionContext | None = None
     ) -> DecomposeResult: ...
 
 
-OpDecomposer = Union[Callable[['cirq.Operation'], DecomposeResult], OpDecomposerWithContext]
+OpDecomposer = Callable[['cirq.Operation'], DecomposeResult] | OpDecomposerWithContext
 
 DECOMPOSE_TARGET_GATESET = ops.Gateset(
     ops.XPowGate,
@@ -71,7 +70,7 @@ DECOMPOSE_TARGET_GATESET = ops.Gateset(
 )
 
 
-def _value_error_describing_bad_operation(op: 'cirq.Operation') -> ValueError:
+def _value_error_describing_bad_operation(op: cirq.Operation) -> ValueError:
     return ValueError(f"Operation doesn't satisfy the given `keep` but can't be decomposed: {op!r}")
 
 
@@ -82,9 +81,16 @@ class DecompositionContext:
     Args:
         qubit_manager: A `cirq.QubitManager` instance to allocate clean / dirty ancilla qubits as
             part of the decompose protocol.
+        extract_global_phases: If set, will extract the global phases from
+         `DECOMPOSE_TARGET_GATESET` into independent global phase operations.
     """
 
-    qubit_manager: 'cirq.QubitManager'
+    qubit_manager: cirq.QubitManager
+    extract_global_phases: bool = False
+
+    def extracting_global_phases(self) -> DecompositionContext:
+        """Returns a copy with the `extract_global_phases` field set."""
+        return dataclasses.replace(self, extract_global_phases=True)
 
 
 class SupportsDecompose(Protocol):
@@ -127,7 +133,7 @@ class SupportsDecompose(Protocol):
         pass
 
     def _decompose_with_context_(
-        self, *, context: Optional[DecompositionContext] = None
+        self, *, context: DecompositionContext | None = None
     ) -> DecomposeResult:
         pass
 
@@ -151,17 +157,17 @@ class SupportsDecomposeWithQubits(Protocol):
     implements `SupportsDecomposeWithQubits`.
     """
 
-    def _decompose_(self, qubits: Tuple['cirq.Qid', ...]) -> DecomposeResult:
+    def _decompose_(self, qubits: tuple[cirq.Qid, ...]) -> DecomposeResult:
         pass
 
     def _decompose_with_context_(
-        self, qubits: Tuple['cirq.Qid', ...], *, context: Optional[DecompositionContext] = None
+        self, qubits: tuple[cirq.Qid, ...], *, context: DecompositionContext | None = None
     ) -> DecomposeResult:
         pass
 
 
 def _try_op_decomposer(
-    val: Any, decomposer: Optional[OpDecomposer], *, context: Optional[DecompositionContext] = None
+    val: Any, decomposer: OpDecomposer | None, *, context: DecompositionContext | None = None
 ) -> DecomposeResult:
     if decomposer is None or not isinstance(val, ops.Operation):
         return None
@@ -174,15 +180,15 @@ def _try_op_decomposer(
 
 @dataclasses.dataclass(frozen=True)
 class _DecomposeArgs:
-    context: Optional[DecompositionContext]
-    intercepting_decomposer: Optional[OpDecomposer]
-    fallback_decomposer: Optional[OpDecomposer]
-    keep: Optional[Callable[['cirq.Operation'], bool]]
-    on_stuck_raise: Union[None, Exception, Callable[['cirq.Operation'], Optional[Exception]]]
+    context: DecompositionContext | None
+    intercepting_decomposer: OpDecomposer | None
+    fallback_decomposer: OpDecomposer | None
+    keep: Callable[[cirq.Operation], bool] | None
+    on_stuck_raise: None | Exception | Callable[[cirq.Operation], Exception | None]
     preserve_structure: bool
 
 
-def _decompose_dfs(item: Any, args: _DecomposeArgs) -> Iterator['cirq.Operation']:
+def _decompose_dfs(item: Any, args: _DecomposeArgs) -> Iterator[cirq.Operation]:
     from cirq.circuits import CircuitOperation, FrozenCircuit
 
     if isinstance(item, ops.Operation):
@@ -224,15 +230,15 @@ def _decompose_dfs(item: Any, args: _DecomposeArgs) -> Iterator['cirq.Operation'
 def decompose(
     val: Any,
     *,
-    intercepting_decomposer: Optional[OpDecomposer] = None,
-    fallback_decomposer: Optional[OpDecomposer] = None,
-    keep: Optional[Callable[['cirq.Operation'], bool]] = None,
-    on_stuck_raise: Union[
-        None, Exception, Callable[['cirq.Operation'], Optional[Exception]]
-    ] = _value_error_describing_bad_operation,
+    intercepting_decomposer: OpDecomposer | None = None,
+    fallback_decomposer: OpDecomposer | None = None,
+    keep: Callable[[cirq.Operation], bool] | None = None,
+    on_stuck_raise: (
+        None | Exception | Callable[[cirq.Operation], Exception | None]
+    ) = _value_error_describing_bad_operation,
     preserve_structure: bool = False,
-    context: Optional[DecompositionContext] = None,
-) -> List['cirq.Operation']:
+    context: DecompositionContext | None = None,
+) -> list[cirq.Operation]:
     """Recursively decomposes a value into `cirq.Operation`s meeting a criteria.
 
     Args:
@@ -309,18 +315,15 @@ def decompose(
     return [*_decompose_dfs(val, args)]
 
 
-# pylint: disable=function-redefined
-
-
 @overload
-def decompose_once(val: Any, **kwargs) -> List['cirq.Operation']:
+def decompose_once(val: Any, **kwargs) -> list[cirq.Operation]:
     pass
 
 
 @overload
 def decompose_once(
     val: Any, default: TDefault, *args, flatten: bool = True, **kwargs
-) -> Union[TDefault, List['cirq.Operation']]:
+) -> TDefault | list[cirq.Operation]:
     pass
 
 
@@ -329,7 +332,7 @@ def decompose_once(
     default=RaiseTypeErrorIfNotProvided,
     *args,
     flatten: bool = True,
-    context: Optional[DecompositionContext] = None,
+    context: DecompositionContext | None = None,
     **kwargs,
 ):
     """Decomposes a value into operations, if possible.
@@ -370,7 +373,7 @@ def decompose_once(
 
     method = getattr(val, '_decompose_with_context_', None)
     decomposed = NotImplemented if method is None else method(*args, **kwargs, context=context)
-    if decomposed is NotImplemented or None:
+    if decomposed is NotImplemented or decomposed is None:
         method = getattr(val, '_decompose_', None)
         decomposed = NotImplemented if method is None else method(*args, **kwargs)
 
@@ -386,39 +389,40 @@ def decompose_once(
         )
     raise TypeError(
         f"object of type {type(val)} does have a _decompose_ method, "
-        "but it returned NotImplemented or None."
+        "but it returned NotImplemented or None. The value is not "
+        "convertible to simpler operations."
     )
 
 
 @overload
 def decompose_once_with_qubits(
     val: Any,
-    qubits: Iterable['cirq.Qid'],
+    qubits: Iterable[cirq.Qid],
     *,
     flatten: bool = True,
-    context: Optional['DecompositionContext'] = None,
-) -> List['cirq.Operation']:
+    context: DecompositionContext | None = None,
+) -> list[cirq.Operation]:
     pass
 
 
 @overload
 def decompose_once_with_qubits(
     val: Any,
-    qubits: Iterable['cirq.Qid'],
-    default: Optional[TDefault],
+    qubits: Iterable[cirq.Qid],
+    default: TDefault | None,
     *,
     flatten: bool = True,
-    context: Optional['DecompositionContext'] = None,
-) -> Union[TDefault, List['cirq.Operation']]:
+    context: DecompositionContext | None = None,
+) -> TDefault | list[cirq.Operation]:
     pass
 
 
 def decompose_once_with_qubits(
     val: Any,
-    qubits: Iterable['cirq.Qid'],
+    qubits: Iterable[cirq.Qid],
     default=RaiseTypeErrorIfNotProvided,
     flatten: bool = True,
-    context: Optional['DecompositionContext'] = None,
+    context: DecompositionContext | None = None,
 ):
     """Decomposes a value into operations on the given qubits.
 
@@ -452,12 +456,9 @@ def decompose_once_with_qubits(
     return decompose_once(val, default, tuple(qubits), flatten=flatten, context=context)
 
 
-# pylint: enable=function-redefined
-
-
 def _try_decompose_into_operations_and_qubits(
     val: Any,
-) -> Tuple[Optional[List['cirq.Operation']], Sequence['cirq.Qid'], Tuple[int, ...]]:
+) -> tuple[list[cirq.Operation] | None, Sequence[cirq.Qid], tuple[int, ...]]:
     """Returns the value's decomposition (if any) and the qubits it applies to."""
 
     if isinstance(val, ops.Gate):
@@ -473,7 +474,7 @@ def _try_decompose_into_operations_and_qubits(
     result = decompose_once(val, None)
     if result is not None:
         qubit_set = set()
-        qid_shape_dict: Dict[cirq.Qid, int] = defaultdict(lambda: 1)
+        qid_shape_dict: dict[cirq.Qid, int] = defaultdict(lambda: 1)
         for op in result:
             for level, q in zip(qid_shape_protocol.qid_shape(op), op.qubits):
                 qubit_set.add(q)

cirq/protocols/decompose_protocol_test.py

@@ -11,8 +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 __future__ import annotations
+
 import itertools
-from typing import Optional
 from unittest import mock
 
 import pytest
@@ -61,7 +63,7 @@ class DecomposeQuditGate:
         yield cirq.identity_each(*qids)
 
 
-def test_decompose_once():
+def test_decompose_once() -> None:
     # No default value results in descriptive error.
     with pytest.raises(TypeError, match='no _decompose_with_context_ or _decompose_ method'):
         _ = cirq.decompose_once(NoMethod())
@@ -88,7 +90,7 @@ def test_decompose_once():
     ]
 
 
-def test_decompose_once_with_qubits():
+def test_decompose_once_with_qubits() -> None:
     qs = cirq.LineQubit.range(3)
 
     # No default value results in descriptive error.
@@ -134,7 +136,7 @@ def test_decompose_once_with_qubits():
     ) == list(cirq.X.on_each(*qs)) + list(cirq.Y.on_each(*qs))
 
 
-def test_decompose_general():
+def test_decompose_general() -> None:
     a, b, c = cirq.LineQubit.range(3)
     no_method = NoMethod()
     assert cirq.decompose(no_method) == [no_method]
@@ -149,7 +151,7 @@ def test_decompose_general():
     )
 
 
-def test_decompose_keep():
+def test_decompose_keep() -> None:
     a, b = cirq.LineQubit.range(2)
 
     # Recursion can be stopped.
@@ -177,7 +179,7 @@ def test_decompose_keep():
     assert cirq.decompose([[[cirq.SWAP(a, b)]]], keep=lambda _: True) == [cirq.SWAP(a, b)]
 
 
-def test_decompose_on_stuck_raise():
+def test_decompose_on_stuck_raise() -> None:
     a, b = cirq.LineQubit.range(2)
     no_method = NoMethod()
 
@@ -207,7 +209,7 @@ def test_decompose_on_stuck_raise():
         assert cirq.decompose([], on_stuck_raise=TypeError('x'))
 
 
-def test_decompose_intercept():
+def test_decompose_intercept() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -228,7 +230,7 @@ def test_decompose_intercept():
 
     # Accepts a context, when provided.
     def _intercept_with_context(
-        op: cirq.Operation, context: Optional[cirq.DecompositionContext] = None
+        op: cirq.Operation, context: cirq.DecompositionContext | None = None
     ):
         assert context is not None
         if op.gate == cirq.SWAP:
@@ -244,7 +246,7 @@ def test_decompose_intercept():
     assert actual == [cirq.X(a), cirq.X(cirq.ops.CleanQubit(0)), cirq.X(b)]
 
 
-def test_decompose_preserving_structure():
+def test_decompose_preserving_structure() -> None:
     a, b = cirq.LineQubit.range(2)
     fc1 = cirq.FrozenCircuit(cirq.SWAP(a, b), cirq.FSimGate(0.1, 0.2).on(a, b))
     cop1_1 = cirq.CircuitOperation(fc1).with_tags('test_tag')
@@ -272,7 +274,7 @@ def test_decompose_preserving_structure():
 
 # Test both intercepting and fallback decomposers.
 @pytest.mark.parametrize('decompose_mode', ['intercept', 'fallback'])
-def test_decompose_preserving_structure_forwards_args(decompose_mode):
+def test_decompose_preserving_structure_forwards_args(decompose_mode) -> None:
     a, b = cirq.LineQubit.range(2)
     fc1 = cirq.FrozenCircuit(cirq.SWAP(a, b), cirq.FSimGate(0.1, 0.2).on(a, b))
     cop1_1 = cirq.CircuitOperation(fc1).with_tags('test_tag')
@@ -282,11 +284,11 @@ def test_decompose_preserving_structure_forwards_args(decompose_mode):
 
     circuit = cirq.Circuit(cop2, cirq.measure(a, b, key='m'))
 
-    def keep_func(op: 'cirq.Operation'):
+    def keep_func(op: cirq.Operation):
         # Only decompose SWAP and X.
         return not isinstance(op.gate, (cirq.SwapPowGate, cirq.XPowGate))
 
-    def x_to_hzh(op: 'cirq.Operation'):
+    def x_to_hzh(op: cirq.Operation):
         if isinstance(op.gate, cirq.XPowGate) and op.gate.exponent == 1:
             return [cirq.H(*op.qubits), cirq.Z(*op.qubits), cirq.H(*op.qubits)]
 
@@ -319,7 +321,7 @@ def test_decompose_preserving_structure_forwards_args(decompose_mode):
     assert actual == expected
 
 
-def test_decompose_tagged_operation():
+def test_decompose_tagged_operation() -> None:
     op = cirq.TaggedOperation(
         cirq.CircuitOperation(
             circuit=cirq.FrozenCircuit(
@@ -374,7 +376,7 @@ class RecursiveDecompose(cirq.Gate):
 
 
 @pytest.mark.parametrize('with_context', [True, False])
-def test_decompose_recursive_dfs(with_context: bool):
+def test_decompose_recursive_dfs(with_context: bool) -> None:
     expected_calls = [
         mock.call.qalloc(True),
         mock.call.qalloc(False),
@@ -423,7 +425,7 @@ class G2(cirq.Gate):
 
 
 @mock.patch('cirq.protocols.decompose_protocol._CONTEXT_COUNTER', itertools.count())
-def test_successive_decompose_once_succeed():
+def test_successive_decompose_once_succeed() -> None:
     op = G2()(cirq.NamedQubit('q'))
     d1 = cirq.decompose_once(op)
     d2 = cirq.decompose_once(d1[0])
@@ -435,7 +437,7 @@ def test_successive_decompose_once_succeed():
     ]
 
 
-def test_decompose_without_context_succeed():
+def test_decompose_without_context_succeed() -> None:
     op = G2()(cirq.NamedQubit('q'))
     assert cirq.decompose(op, keep=lambda op: op.gate is cirq.CNOT) == [
         cirq.CNOT(
@@ -443,3 +445,12 @@ def test_decompose_without_context_succeed():
             cirq.ops.CleanQubit(1, prefix='_decompose_protocol'),
         )
     ]
+
+
+def test_extracting_global_phases() -> None:
+    qm = cirq.SimpleQubitManager()
+    context = cirq.DecompositionContext(qm)
+    new_context = context.extracting_global_phases()
+    assert not context.extract_global_phases
+    assert new_context.extract_global_phases
+    assert new_context.qubit_manager is qm