cirq-core 1.1.0.dev20221219200817__py3-none-any.whl → 1.2.0__py3-none-any.whl

cirq/__init__.py

@@ -16,6 +16,8 @@
 
 from cirq import _import
 
+from cirq._compat import __cirq_debug__, with_debug
+
 # A module can only depend on modules imported earlier in this list of modules
 # at import time.  Pytest will fail otherwise (enforced by
 # dev_tools/import_test.py).
@@ -236,6 +238,7 @@ from cirq.ops import (
     LinearCombinationOfOperations,
     MatrixGate,
     MixedUnitaryChannel,
+    M,
     measure,
     measure_each,
     measure_paulistring_terms,
@@ -281,9 +284,11 @@ from cirq.ops import (
     qft,
     Qid,
     QuantumFourierTransformGate,
+    QubitManager,
     QubitOrder,
     QubitOrderOrList,
     QubitPermutationGate,
+    R,
     reset,
     reset_each,
     ResetChannel,
@@ -366,6 +371,7 @@ from cirq.transformers import (
     parameterized_2q_op_to_sqrt_iswap_operations,
     prepare_two_qubit_state_using_cz,
     prepare_two_qubit_state_using_sqrt_iswap,
+    quantum_shannon_decomposition,
     RouteCQC,
     routed_circuit_with_mapping,
     SqrtIswapTargetGateset,
@@ -498,6 +504,7 @@ from cirq.study import (
     Result,
     UnitSweep,
     Zip,
+    ZipLongest,
 )
 
 from cirq.value import (
@@ -561,6 +568,7 @@ from cirq.protocols import (
     decompose,
     decompose_once,
     decompose_once_with_qubits,
+    DecompositionContext,
     DEFAULT_RESOLVERS,
     definitely_commutes,
     equal_up_to_global_phase,

cirq/_compat.py

@@ -14,6 +14,7 @@
 
 """Workarounds for compatibility issues between versions and libraries."""
 import contextlib
+import contextvars
 import dataclasses
 import functools
 import importlib
@@ -24,15 +25,41 @@ import sys
 import traceback
 import warnings
 from types import ModuleType
-from typing import Any, Callable, Dict, Optional, overload, Set, Tuple, Type, TypeVar
+from typing import Any, Callable, Dict, Iterator, Optional, overload, Set, Tuple, Type, TypeVar
 
 import numpy as np
 import pandas as pd
 import sympy
 import sympy.printing.repr
 
+from cirq._doc import document
+
 ALLOW_DEPRECATION_IN_TEST = 'ALLOW_DEPRECATION_IN_TEST'
 
+__cirq_debug__ = contextvars.ContextVar('__cirq_debug__', default=__debug__)
+document(
+    __cirq_debug__,
+    "A cirq specific flag which can be used to conditionally turn off all validations across Cirq "
+    "to boost performance in production mode. Defaults to python's built-in constant __debug__. "
+    "The flag is implemented as a `ContextVar` and is thread safe.",
+)
+
+
+@contextlib.contextmanager
+def with_debug(value: bool) -> Iterator[None]:
+    """Sets the value of global constant `cirq.__cirq_debug__` within the context.
+
+    If `__cirq_debug__` is set to False, all validations in Cirq are disabled to optimize
+    performance. Users should use the `cirq.with_debug` context manager instead of manually
+    mutating the value of `__cirq_debug__` flag. On exit, the context manager resets the
+    value of `__cirq_debug__` flag to what it was before entering the context manager.
+    """
+    token = __cirq_debug__.set(value)
+    try:
+        yield
+    finally:
+        __cirq_debug__.reset(token)
+
 
 try:
     from functools import cached_property  # pylint: disable=unused-import
@@ -138,9 +165,7 @@ def proper_repr(value: Any) -> str:
         return Printer().doprint(value)
 
     if isinstance(value, np.ndarray):
-        if np.issubdtype(value.dtype, np.datetime64):
-            return f'np.array({value.tolist()!r}, dtype=np.{value.dtype!r})'
-        return f'np.array({value.tolist()!r}, dtype=np.{value.dtype})'
+        return f'np.array({value.tolist()!r}, dtype=np.{value.dtype!r})'
 
     if isinstance(value, pd.MultiIndex):
         return f'pd.MultiIndex.from_tuples({repr(list(value))}, names={repr(list(value.names))})'

cirq/_compat_test.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 import collections
 import dataclasses
-import importlib
+import importlib.metadata
 import logging
 import multiprocessing
 import os
@@ -51,6 +51,16 @@ from cirq._compat import (
 )
 
 
+def test_with_debug():
+    assert cirq.__cirq_debug__.get()
+    with cirq.with_debug(False):
+        assert not cirq.__cirq_debug__.get()
+        with cirq.with_debug(True):
+            assert cirq.__cirq_debug__.get()
+        assert not cirq.__cirq_debug__.get()
+    assert cirq.__cirq_debug__.get()
+
+
 def test_proper_repr():
     v = sympy.Symbol('t') * 3
     v2 = eval(proper_repr(v))
@@ -88,7 +98,7 @@ def test_proper_repr_data_frame():
     pd.testing.assert_frame_equal(df2, df)
 
 
-def test_dataclass_repr_simple():
+def test_dataclass_repr_simple() -> None:
     @dataclasses.dataclass
     class TestClass1:
         x: int
@@ -101,7 +111,7 @@ def test_dataclass_repr_simple():
     assert repr(TestClass1(5, 'hi')) == "cirq.TestClass1(x=5, y='hi')"
 
 
-def test_dataclass_repr_numpy():
+def test_dataclass_repr_numpy() -> None:
     @dataclasses.dataclass
     class TestClass2:
         x: np.ndarray
@@ -110,7 +120,10 @@ def test_dataclass_repr_numpy():
             return dataclass_repr(self, namespace='cirq.testing')
 
     tc = TestClass2(np.ones(3))
-    assert repr(tc) == "cirq.testing.TestClass2(x=np.array([1.0, 1.0, 1.0], dtype=np.float64))"
+    assert (
+        repr(tc)
+        == "cirq.testing.TestClass2(x=np.array([1.0, 1.0, 1.0], dtype=np.dtype('float64')))"
+    )
 
 
 def test_proper_eq():
@@ -187,9 +200,8 @@ def test_deprecated():
 
     with pytest.raises(AssertionError, match='deadline should match vX.Y'):
         # pylint: disable=unused-variable
-        # coverage: ignore
         @deprecated(deadline='invalid', fix='Roll some dice.')
-        def badly_deprecated_func(*args, **kwargs):
+        def badly_deprecated_func(*args, **kwargs):  # pragma: no cover
             return new_func(*args, **kwargs)
 
         # pylint: enable=unused-variable
@@ -245,8 +257,7 @@ def test_deprecated_parameter():
             rewrite=lambda args, kwargs: (args, {'new_count': kwargs['double_count'] * 2}),
         )
         # pylint: disable=unused-variable
-        # coverage: ignore
-        def f_with_badly_deprecated_param(new_count):
+        def f_with_badly_deprecated_param(new_count):  # pragma: no cover
             return new_count
 
         # pylint: enable=unused-variable
@@ -358,9 +369,8 @@ def test_deprecated_class():
 
     with pytest.raises(AssertionError, match='deadline should match vX.Y'):
         # pylint: disable=unused-variable
-        # coverage: ignore
         @deprecated_class(deadline='invalid', fix='theFix', name='foo')
-        class BadlyDeprecatedClass(NewClass):
+        class BadlyDeprecatedClass(NewClass):  # pragma: no cover
             ...
 
         # pylint: enable=unused-variable
@@ -606,8 +616,6 @@ def subprocess_context(test_func):
         "it to this method?"
     )
 
-    import os
-
     ctx = multiprocessing.get_context('spawn' if os.name == 'nt' else 'fork')
 
     exception = ctx.Queue()
@@ -619,8 +627,7 @@ def subprocess_context(test_func):
         p.start()
         p.join()
         result = exception.get()
-        if result:
-            # coverage: ignore
+        if result:  # pragma: no cover
             ex_type, msg, ex_trace = result
             if ex_type == "Skipped":
                 warnings.warn(f"Skipping: {ex_type}: {msg}\n{ex_trace}")
@@ -709,21 +716,12 @@ def test_metadata_search_path():
     subprocess_context(_test_metadata_search_path_inner)()
 
 
-def _test_metadata_search_path_inner():
+def _test_metadata_search_path_inner():  # pragma: no cover
     # initialize the DeprecatedModuleFinders
     # pylint: disable=unused-import
     import cirq.testing._compat_test_data.module_a
 
-    try:
-        # importlib.metadata for python 3.8+
-        # coverage: ignore
-        import importlib.metadata as m
-    except:  # coverage: ignore
-        # coverage: ignore
-        # importlib_metadata for python <3.8
-        m = pytest.importorskip("importlib_metadata")
-
-    assert m.metadata('flynt')
+    assert importlib.metadata.metadata('numpy')
 
 
 def test_metadata_distributions_after_deprecated_submodule():
@@ -990,7 +988,7 @@ def test_cached_property():
 
 
 class Bar:
-    def __init__(self):
+    def __init__(self) -> None:
         self.foo_calls: Dict[int, int] = collections.Counter()
         self.bar_calls: Dict[int, int] = collections.Counter()
 

cirq/_version.py

@@ -1 +1,32 @@
-__version__ = "1.1.0.dev20221219200817"
+# Copyright 2018 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+
+"""Define version number here, read it from setup.py automatically,
+and warn users that the latest version of cirq uses python 3.9+"""
+
+import sys
+
+if sys.version_info < (3, 9, 0):
+    # coverage: ignore
+    raise SystemError(
+        "You installed the latest version of cirq but aren't on python 3.9+.\n"
+        'To fix this error, you need to either:\n'
+        '\n'
+        'A) Update to python 3.9 or later.\n'
+        '- OR -\n'
+        'B) Explicitly install an older deprecated-but-compatible version '
+        'of cirq (e.g. "python -m pip install cirq==1.1.*")'
+    )
+
+__version__ = "1.2.0"

cirq/_version_test.py

@@ -3,4 +3,4 @@ import cirq
 
 
 def test_version():
-    assert cirq.__version__ == "1.1.0.dev"
+    assert cirq.__version__ == "1.2.0.dev"

cirq/circuits/_block_diagram_drawer_test.py

@@ -11,6 +11,7 @@
 # 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 pytest
@@ -31,13 +32,13 @@ def _assert_same_diagram(actual: str, expected: str):
         "Diagram differs from the desired diagram.\n"
         '\n'
         'Actual diagram:\n'
-        '{}\n'
+        f'{actual}\n'
         '\n'
         'Desired diagram:\n'
-        '{}\n'
+        f'{expected}\n'
         '\n'
         'Highlighted differences:\n'
-        '{}\n'.format(actual, expected, cirq.testing.highlight_text_differences(actual, expected))
+        f'{cirq.testing.highlight_text_differences(actual, expected)}\n'
     )
 
 

cirq/circuits/circuit.py

@@ -47,6 +47,7 @@ from typing import (
     TypeVar,
     Union,
 )
+from typing_extensions import Self
 
 import networkx
 import numpy as np
@@ -236,15 +237,15 @@ class AbstractCircuit(abc.ABC):
         pass
 
     @overload
-    def __getitem__(self: CIRCUIT_TYPE, key: slice) -> CIRCUIT_TYPE:
+    def __getitem__(self, key: slice) -> Self:
         pass
 
     @overload
-    def __getitem__(self: CIRCUIT_TYPE, key: Tuple[slice, 'cirq.Qid']) -> CIRCUIT_TYPE:
+    def __getitem__(self, key: Tuple[slice, 'cirq.Qid']) -> Self:
         pass
 
     @overload
-    def __getitem__(self: CIRCUIT_TYPE, key: Tuple[slice, Iterable['cirq.Qid']]) -> CIRCUIT_TYPE:
+    def __getitem__(self, key: Tuple[slice, Iterable['cirq.Qid']]) -> Self:
         pass
 
     def __getitem__(self, key):
@@ -305,7 +306,10 @@ class AbstractCircuit(abc.ABC):
         return None
 
     def next_moment_operating_on(
-        self, qubits: Iterable['cirq.Qid'], start_moment_index: int = 0, max_distance: int = None
+        self,
+        qubits: Iterable['cirq.Qid'],
+        start_moment_index: int = 0,
+        max_distance: Optional[int] = None,
     ) -> Optional[int]:
         """Finds the index of the next moment that touches the given qubits.
 
@@ -910,9 +914,7 @@ class AbstractCircuit(abc.ABC):
         """
         return (op for moment in self for op in moment.operations)
 
-    def map_operations(
-        self: CIRCUIT_TYPE, func: Callable[['cirq.Operation'], 'cirq.OP_TREE']
-    ) -> CIRCUIT_TYPE:
+    def map_operations(self, func: Callable[['cirq.Operation'], 'cirq.OP_TREE']) -> Self:
         """Applies the given function to all operations in this circuit.
 
         Args:
@@ -1284,9 +1286,7 @@ class AbstractCircuit(abc.ABC):
     def _parameter_names_(self) -> AbstractSet[str]:
         return {name for op in self.all_operations() for name in protocols.parameter_names(op)}
 
-    def _resolve_parameters_(
-        self: CIRCUIT_TYPE, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> CIRCUIT_TYPE:
+    def _resolve_parameters_(self, resolver: 'cirq.ParamResolver', recursive: bool) -> Self:
         changed = False
         resolved_moments: List['cirq.Moment'] = []
         for moment in self:
@@ -1458,7 +1458,7 @@ class AbstractCircuit(abc.ABC):
         are placed one after the other and then moved inward until just before
         their operations would collide. If any of the circuits do not share
         qubits and so would not collide, the starts or ends of the circuits will
-        be aligned, acording to the given align parameter.
+        be aligned, according to the given align parameter.
 
         Beware that this method is *not* associative. For example:
 
@@ -1537,7 +1537,7 @@ class AbstractCircuit(abc.ABC):
                 uf.union(*op.qubits)
         return sorted([qs for qs in uf.to_sets()], key=min)
 
-    def factorize(self: CIRCUIT_TYPE) -> Iterable[CIRCUIT_TYPE]:
+    def factorize(self) -> Iterable[Self]:
         """Factorize circuit into a sequence of independent circuits (factors).
 
         Factorization is possible when the circuit's qubits can be divided
@@ -1776,12 +1776,10 @@ class Circuit(AbstractCircuit):
                 Non-moment entries will be inserted according to the EARLIEST
                 insertion strategy.
         """
-        # These are dicts from the qubit/key to the greatest moment index that has it. It is safe
-        # to default to `-1`, as that is interpreted as meaning the zeroth index onward does not
-        # have this value.
-        qubit_indexes: Dict['cirq.Qid', int] = defaultdict(lambda: -1)
-        mkey_indexes: Dict['cirq.MeasurementKey', int] = defaultdict(lambda: -1)
-        ckey_indexes: Dict['cirq.MeasurementKey', int] = defaultdict(lambda: -1)
+        # These are dicts from the qubit/key to the greatest moment index that has it.
+        qubit_indices: Dict['cirq.Qid', int] = {}
+        mkey_indices: Dict['cirq.MeasurementKey', int] = {}
+        ckey_indices: Dict['cirq.MeasurementKey', int] = {}
 
         # We also maintain the dict from moment index to moments/ops that go into it, for use when
         # building the actual moments at the end.
@@ -1793,46 +1791,17 @@ class Circuit(AbstractCircuit):
 
         # "mop" means current moment-or-operation
         for mop in ops.flatten_to_ops_or_moments(contents):
-            mop_qubits = mop.qubits
-            mop_mkeys = protocols.measurement_key_objs(mop)
-            mop_ckeys = protocols.control_keys(mop)
 
-            # Both branches define `i`, the moment index at which to place the mop.
+            # Identify the index of the moment to place this `mop` into.
+            placement_index = get_earliest_accommodating_moment_index(
+                mop, qubit_indices, mkey_indices, ckey_indices, length
+            )
+            length = max(length, placement_index + 1)  # update the length of the circuit thus far
+
             if isinstance(mop, Moment):
-                # We always append moment to the end, to be consistent with `self.append`
-                i = length
-                moments_by_index[i] = mop
+                moments_by_index[placement_index] = mop
             else:
-                # Initially we define `i` as the greatest moment index that has a conflict. `-1` is
-                # the initial conflict, and we search for larger ones. Once we get the largest one,
-                # we increment i by 1 to set the placement index.
-                i = -1
-
-                # Look for the maximum conflict; i.e. a moment that has a qubit the same as one of
-                # this op's qubits, that has a measurement or control key the same as one of this
-                # op's measurement keys, or that has a measurement key the same as one of this op's
-                # control keys. (Control keys alone can commute past each other). The `ifs` are
-                # logically unnecessary but seem to make this slightly faster.
-                if mop_qubits:
-                    i = max(i, *[qubit_indexes[q] for q in mop_qubits])
-                if mop_mkeys:
-                    i = max(i, *[mkey_indexes[k] for k in mop_mkeys])
-                    i = max(i, *[ckey_indexes[k] for k in mop_mkeys])
-                if mop_ckeys:
-                    i = max(i, *[mkey_indexes[k] for k in mop_ckeys])
-                i += 1
-                op_lists_by_index[i].append(mop)
-
-            # Update our dicts with data from the latest mop placement. Note `i` will always be
-            # greater than the existing value for all of these, by construction, so there is no
-            # need to do a `max(i, existing)`.
-            for q in mop_qubits:
-                qubit_indexes[q] = i
-            for k in mop_mkeys:
-                mkey_indexes[k] = i
-            for k in mop_ckeys:
-                ckey_indexes[k] = i
-            length = max(length, i + 1)
+                op_lists_by_index[placement_index].append(mop)
 
         # Finally, once everything is placed, we can construct and append the actual moments for
         # each index.
@@ -1861,9 +1830,8 @@ class Circuit(AbstractCircuit):
         pass
 
     def __setitem__(self, key, value):
-        if isinstance(key, int):
-            if not isinstance(value, Moment):
-                raise TypeError('Can only assign Moments into Circuits.')
+        if isinstance(key, int) and not isinstance(value, Moment):
+            raise TypeError('Can only assign Moments into Circuits.')
 
         if isinstance(key, slice):
             value = list(value)
@@ -2160,7 +2128,7 @@ class Circuit(AbstractCircuit):
         self,
         early_frontier: Dict['cirq.Qid', int],
         late_frontier: Dict['cirq.Qid', int],
-        update_qubits: Iterable['cirq.Qid'] = None,
+        update_qubits: Optional[Iterable['cirq.Qid']] = None,
     ) -> Tuple[int, int]:
         """Inserts moments to separate two frontiers.
 
@@ -2230,7 +2198,10 @@ class Circuit(AbstractCircuit):
             )
 
     def insert_at_frontier(
-        self, operations: 'cirq.OP_TREE', start: int, frontier: Dict['cirq.Qid', int] = None
+        self,
+        operations: 'cirq.OP_TREE',
+        start: int,
+        frontier: Optional[Dict['cirq.Qid', int]] = None,
     ) -> Dict['cirq.Qid', int]:
         """Inserts operations inline at frontier.
 
@@ -2421,7 +2392,9 @@ class Circuit(AbstractCircuit):
 
 
 def _pick_inserted_ops_moment_indices(
-    operations: Sequence['cirq.Operation'], start: int = 0, frontier: Dict['cirq.Qid', int] = None
+    operations: Sequence['cirq.Operation'],
+    start: int = 0,
+    frontier: Optional[Dict['cirq.Qid', int]] = None,
 ) -> Tuple[Sequence[int], Dict['cirq.Qid', int]]:
     """Greedily assigns operations to moments.
 
@@ -2595,8 +2568,7 @@ def _get_global_phase_and_tags_for_op(op: 'cirq.Operation') -> Tuple[Optional[co
     elif isinstance(op.untagged, CircuitOperation):
         op_phase, op_tags = _get_global_phase_and_tags_for_ops(op.untagged.circuit.all_operations())
         return op_phase, list(op.tags) + op_tags
-    else:
-        return None, []
+    return None, []
 
 
 def _get_global_phase_and_tags_for_ops(op_list: Any) -> Tuple[Optional[complex], List[Any]]:
@@ -2755,3 +2727,77 @@ def _group_until_different(items: Iterable[_TIn], key: Callable[[_TIn], _TKey],
         Tuples containing the group key and item values.
     """
     return ((k, [val(i) for i in v]) for (k, v) in itertools.groupby(items, key))
+
+
+def get_earliest_accommodating_moment_index(
+    moment_or_operation: Union['cirq.Moment', 'cirq.Operation'],
+    qubit_indices: Dict['cirq.Qid', int],
+    mkey_indices: Dict['cirq.MeasurementKey', int],
+    ckey_indices: Dict['cirq.MeasurementKey', int],
+    length: Optional[int] = None,
+) -> int:
+    """Get the index of the earliest moment that can accommodate the given moment or operation.
+
+    Updates the dictionaries keeping track of the last moment index addressing a given qubit,
+    measurement key, and control key.
+
+    Args:
+        moment_or_operation: The moment operation in question.
+        qubit_indices: A dictionary mapping qubits to the latest moments that address them.
+        mkey_indices: A dictionary mapping measureent keys to the latest moments that address them.
+        ckey_indices: A dictionary mapping control keys to the latest moments that address them.
+        length: The length of the circuit that we are trying to insert a moment or operation into.
+            Should probably be equal to the maximum of the values in `qubit_indices`,
+            `mkey_indices`, and `ckey_indices`.
+
+    Returns:
+        The integer index of the earliest moment that can accommodate the given moment or operation.
+    """
+    mop_qubits = moment_or_operation.qubits
+    mop_mkeys = protocols.measurement_key_objs(moment_or_operation)
+    mop_ckeys = protocols.control_keys(moment_or_operation)
+
+    if isinstance(moment_or_operation, Moment):
+        # For consistency with `Circuit.append`, moments always get placed at the end of a circuit.
+        if length is not None:
+            last_conflict = length - 1
+        else:
+            last_conflict = max(
+                [*qubit_indices.values(), *mkey_indices.values(), *ckey_indices.values(), -1]
+            )
+
+    else:
+        # We start by searching for the `latest_conflict` moment index, which we will increment by
+        # `1` to identify the earliest moment that *does not* conflict with the given operation.
+        # The `latest_conflict` is initialized to `-1` before searching for later conflicting
+        # moments.
+        last_conflict = -1
+
+        # Look for the maximum conflict; i.e. a moment that has a qubit the same as one of this op's
+        # qubits, that has a measurement or control key the same as one of this op's measurement
+        # keys, or that has a measurement key the same as one of this op's control keys. (Control
+        # keys alone can commute past each other). The `ifs` are logically unnecessary but seem to
+        # make this slightly faster.
+        if mop_qubits:
+            last_conflict = max(
+                last_conflict, *[qubit_indices.get(qubit, -1) for qubit in mop_qubits]
+            )
+        if mop_mkeys:
+            last_conflict = max(last_conflict, *[mkey_indices.get(key, -1) for key in mop_mkeys])
+            last_conflict = max(last_conflict, *[ckey_indices.get(key, -1) for key in mop_mkeys])
+        if mop_ckeys:
+            last_conflict = max(last_conflict, *[mkey_indices.get(key, -1) for key in mop_ckeys])
+
+    # The index of the moment to place this moment or operaton ("mop") into.
+    mop_index = last_conflict + 1
+
+    # Update our dicts with data from this `mop` placement. Note `mop_index` will always be greater
+    # than the existing value for all of these, by construction.
+    for qubit in mop_qubits:
+        qubit_indices[qubit] = mop_index
+    for key in mop_mkeys:
+        mkey_indices[key] = mop_index
+    for key in mop_ckeys:
+        ckey_indices[key] = mop_index
+
+    return mop_index

cirq/circuits/circuit_operation.py

@@ -11,6 +11,7 @@
 # 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.
+
 """A structure for encapsulating entire circuits in an operation.
 
 A CircuitOperation is an Operation object that wraps a FrozenCircuit. When
@@ -459,9 +460,7 @@ class CircuitOperation(ops.Operation):
         # TODO: support out-of-line subcircuit definition in string format.
         msg_lines = str(self.circuit).split('\n')
         msg_width = max([len(line) for line in msg_lines])
-        circuit_msg = '\n'.join(
-            '[ {line:<{width}} ]'.format(line=line, width=msg_width) for line in msg_lines
-        )
+        circuit_msg = '\n'.join(f'[ {line:<{msg_width}} ]' for line in msg_lines)
         args = []
 
         def dict_str(d: Mapping) -> str:

cirq/circuits/circuit_operation_test.py

@@ -274,7 +274,7 @@ def test_recursive_params():
 
 @pytest.mark.parametrize('add_measurements', [True, False])
 @pytest.mark.parametrize('use_default_ids_for_initial_rep', [True, False])
-def test_repeat(add_measurements, use_default_ids_for_initial_rep):
+def test_repeat(add_measurements: bool, use_default_ids_for_initial_rep: bool) -> None:
     a, b = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(cirq.H(a), cirq.CX(a, b))
     if add_measurements:
@@ -327,9 +327,9 @@ def test_repeat(add_measurements, use_default_ids_for_initial_rep):
         _ = op_base.repeat()
 
     with pytest.raises(TypeError, match='Only integer or sympy repetitions are allowed'):
-        _ = op_base.repeat(1.3)
-    assert op_base.repeat(3.00000000001).repetitions == 3
-    assert op_base.repeat(2.99999999999).repetitions == 3
+        _ = op_base.repeat(1.3)  # type: ignore[arg-type]
+    assert op_base.repeat(3.00000000001).repetitions == 3  # type: ignore[arg-type]
+    assert op_base.repeat(2.99999999999).repetitions == 3  # type: ignore[arg-type]
 
 
 @pytest.mark.parametrize('add_measurements', [True, False])

cirq/circuits/circuit_test.py

@@ -834,6 +834,17 @@ def test_insert_moment():
         assert c.operation_at(qubit, actual_index) == operation[0]
 
 
+def test_circuit_length_inference():
+    # tests that `get_earliest_accommodating_moment_index` properly computes circuit length
+    circuit = cirq.Circuit(cirq.X(cirq.q(0)))
+    qubit_indices = {cirq.q(0): 0}
+    mkey_indices = {}
+    ckey_indices = {}
+    assert circuits.circuit.get_earliest_accommodating_moment_index(
+        cirq.Moment(), qubit_indices, mkey_indices, ckey_indices
+    ) == len(circuit)
+
+
 def test_insert_inline_near_start():
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')