cirq-core 1.2.0.dev20230717232332__py3-none-any.whl → 1.3.0__py3-none-any.whl

cirq/circuits/circuit_test.py

@@ -23,7 +23,6 @@ import pytest
 import sympy
 
 import cirq
-import cirq.testing
 from cirq import circuits
 from cirq import ops
 from cirq.testing.devices import ValidatingTestDevice
@@ -72,19 +71,32 @@ moment_and_op_type_validating_device = _MomentAndOpTypeValidatingDeviceType()
 
 def test_from_moments():
     a, b, c, d = cirq.LineQubit.range(4)
-    assert cirq.Circuit.from_moments(
+    moment = cirq.Moment(cirq.Z(a), cirq.Z(b))
+    subcircuit = cirq.FrozenCircuit.from_moments(cirq.X(c), cirq.Y(d))
+    circuit = cirq.Circuit.from_moments(
+        moment,
+        subcircuit,
         [cirq.X(a), cirq.Y(b)],
         [cirq.X(c)],
         [],
         cirq.Z(d),
         [cirq.measure(a, b, key='ab'), cirq.measure(c, d, key='cd')],
-    ) == cirq.Circuit(
+    )
+    assert circuit == cirq.Circuit(
+        cirq.Moment(cirq.Z(a), cirq.Z(b)),
+        cirq.Moment(
+            cirq.CircuitOperation(
+                cirq.FrozenCircuit(cirq.Moment(cirq.X(c)), cirq.Moment(cirq.Y(d)))
+            )
+        ),
         cirq.Moment(cirq.X(a), cirq.Y(b)),
         cirq.Moment(cirq.X(c)),
         cirq.Moment(),
         cirq.Moment(cirq.Z(d)),
         cirq.Moment(cirq.measure(a, b, key='ab'), cirq.measure(c, d, key='cd')),
     )
+    assert circuit[0] is moment
+    assert circuit[1].operations[0].circuit is subcircuit
 
 
 def test_alignment():
@@ -4521,6 +4533,100 @@ def test_freeze_not_relocate_moments():
     assert [mc is fc for mc, fc in zip(c, f)] == [True, True]
 
 
+def test_freeze_is_cached():
+    q = cirq.q(0)
+    c = cirq.Circuit(cirq.X(q), cirq.measure(q))
+    f0 = c.freeze()
+    f1 = c.freeze()
+    assert f1 is f0
+
+    c.append(cirq.Y(q))
+    f2 = c.freeze()
+    f3 = c.freeze()
+    assert f2 is not f1
+    assert f3 is f2
+
+    c[-1] = cirq.Moment(cirq.Y(q))
+    f4 = c.freeze()
+    f5 = c.freeze()
+    assert f4 is not f3
+    assert f5 is f4
+
+
+@pytest.mark.parametrize(
+    "circuit, mutate",
+    [
+        (
+            cirq.Circuit(cirq.X(cirq.q(0)), cirq.M(cirq.q(0))),
+            lambda c: c.__setitem__(0, cirq.Moment(cirq.Y(cirq.q(0)))),
+        ),
+        (cirq.Circuit(cirq.X(cirq.q(0)), cirq.M(cirq.q(0))), lambda c: c.__delitem__(0)),
+        (cirq.Circuit(cirq.X(cirq.q(0)), cirq.M(cirq.q(0))), lambda c: c.__imul__(2)),
+        (
+            cirq.Circuit(cirq.X(cirq.q(0)), cirq.M(cirq.q(0))),
+            lambda c: c.insert(1, cirq.Y(cirq.q(0))),
+        ),
+        (
+            cirq.Circuit(cirq.X(cirq.q(0)), cirq.M(cirq.q(0))),
+            lambda c: c.insert_into_range([cirq.Y(cirq.q(1)), cirq.M(cirq.q(1))], 0, 2),
+        ),
+        (
+            cirq.Circuit(cirq.X(cirq.q(0)), cirq.M(cirq.q(0))),
+            lambda c: c.insert_at_frontier([cirq.Y(cirq.q(0)), cirq.Y(cirq.q(1))], 1),
+        ),
+        (
+            cirq.Circuit(cirq.X(cirq.q(0)), cirq.M(cirq.q(0))),
+            lambda c: c.batch_replace([(0, cirq.X(cirq.q(0)), cirq.Y(cirq.q(0)))]),
+        ),
+        (
+            cirq.Circuit(cirq.X(cirq.q(0)), cirq.M(cirq.q(0), cirq.q(1))),
+            lambda c: c.batch_insert_into([(0, cirq.X(cirq.q(1)))]),
+        ),
+        (
+            cirq.Circuit(cirq.X(cirq.q(0)), cirq.M(cirq.q(0))),
+            lambda c: c.batch_insert([(1, cirq.Y(cirq.q(0)))]),
+        ),
+        (
+            cirq.Circuit(cirq.X(cirq.q(0)), cirq.M(cirq.q(0))),
+            lambda c: c.clear_operations_touching([cirq.q(0)], [0]),
+        ),
+    ],
+)
+def test_mutation_clears_cached_attributes(circuit, mutate):
+    cached_attributes = [
+        "_all_qubits",
+        "_frozen",
+        "_is_measurement",
+        "_is_parameterized",
+        "_parameter_names",
+    ]
+
+    for attr in cached_attributes:
+        assert getattr(circuit, attr) is None, f"{attr=} is not None"
+
+    # Check that attributes are cached after getting them.
+    qubits = circuit.all_qubits()
+    frozen = circuit.freeze()
+    is_measurement = cirq.is_measurement(circuit)
+    is_parameterized = cirq.is_parameterized(circuit)
+    parameter_names = cirq.parameter_names(circuit)
+
+    for attr in cached_attributes:
+        assert getattr(circuit, attr) is not None, f"{attr=} is None"
+
+    # Check that getting again returns same object.
+    assert circuit.all_qubits() is qubits
+    assert circuit.freeze() is frozen
+    assert cirq.is_measurement(circuit) is is_measurement
+    assert cirq.is_parameterized(circuit) is is_parameterized
+    assert cirq.parameter_names(circuit) is parameter_names
+
+    # Check that attributes are cleared after mutation.
+    mutate(circuit)
+    for attr in cached_attributes:
+        assert getattr(circuit, attr) is None, f"{attr=} is not None"
+
+
 def test_factorize_one_factor():
     circuit = cirq.Circuit()
     q0, q1, q2 = cirq.LineQubit.range(3)

cirq/circuits/frozen_circuit.py

@@ -12,7 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """An immutable version of the Circuit data structure."""
-from typing import AbstractSet, FrozenSet, Iterable, Iterator, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import (
+    AbstractSet,
+    FrozenSet,
+    Hashable,
+    Iterable,
+    Iterator,
+    Sequence,
+    Tuple,
+    TYPE_CHECKING,
+    Union,
+)
 
 import numpy as np
 
@@ -34,7 +44,10 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
     """
 
     def __init__(
-        self, *contents: 'cirq.OP_TREE', strategy: 'cirq.InsertStrategy' = InsertStrategy.EARLIEST
+        self,
+        *contents: 'cirq.OP_TREE',
+        strategy: 'cirq.InsertStrategy' = InsertStrategy.EARLIEST,
+        tags: Sequence[Hashable] = (),
     ) -> None:
         """Initializes a frozen circuit.
 
@@ -47,9 +60,14 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
             strategy: When initializing the circuit with operations and moments
                 from `contents`, this determines how the operations are packed
                 together.
+            tags: A sequence of any type of object that is useful to attach metadata
+                to this circuit as long as the type is hashable.  If you wish the
+                resulting circuit to be eventually serialized into JSON, you should
+                also restrict the tags to be JSON serializable.
         """
         base = Circuit(contents, strategy=strategy)
         self._moments = tuple(base.moments)
+        self._tags = tuple(tags)
 
     @classmethod
     def _from_moments(cls, moments: Iterable['cirq.Moment']) -> 'FrozenCircuit':
@@ -61,10 +79,41 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
     def moments(self) -> Sequence['cirq.Moment']:
         return self._moments
 
+    def freeze(self) -> 'cirq.FrozenCircuit':
+        return self
+
+    def unfreeze(self, copy: bool = True) -> 'cirq.Circuit':
+        return Circuit.from_moments(*self)
+
+    @property
+    def tags(self) -> Tuple[Hashable, ...]:
+        """Returns a tuple of the Circuit's tags."""
+        return self._tags
+
+    @_compat.cached_property
+    def untagged(self) -> 'cirq.FrozenCircuit':
+        """Returns the underlying FrozenCircuit without any tags."""
+        return self._from_moments(self._moments) if self.tags else self
+
+    def with_tags(self, *new_tags: Hashable) -> 'cirq.FrozenCircuit':
+        """Creates a new tagged `FrozenCircuit` with `self.tags` and `new_tags` combined."""
+        if not new_tags:
+            return self
+        new_circuit = FrozenCircuit(tags=self.tags + new_tags)
+        new_circuit._moments = self._moments
+        return new_circuit
+
     @_compat.cached_method
     def __hash__(self) -> int:
         # Explicitly cached for performance
-        return hash((self.moments,))
+        return hash((self.moments, self.tags))
+
+    def __eq__(self, other):
+        super_eq = super().__eq__(other)
+        if super_eq is not True:
+            return super_eq
+        other_tags = other.tags if isinstance(other, FrozenCircuit) else ()
+        return self.tags == other_tags
 
     def __getstate__(self):
         # Don't save hash when pickling; see #3777.
@@ -130,11 +179,23 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
 
     @_compat.cached_method
     def _is_parameterized_(self) -> bool:
-        return super()._is_parameterized_()
+        return super()._is_parameterized_() or any(
+            protocols.is_parameterized(tag) for tag in self.tags
+        )
 
     @_compat.cached_method
     def _parameter_names_(self) -> AbstractSet[str]:
-        return super()._parameter_names_()
+        tag_params = {name for tag in self.tags for name in protocols.parameter_names(tag)}
+        return super()._parameter_names_() | tag_params
+
+    def _resolve_parameters_(
+        self, resolver: 'cirq.ParamResolver', recursive: bool
+    ) -> 'cirq.FrozenCircuit':
+        resolved_circuit = super()._resolve_parameters_(resolver, recursive)
+        resolved_tags = [
+            protocols.resolve_parameters(tag, resolver, recursive) for tag in self.tags
+        ]
+        return resolved_circuit.with_tags(*resolved_tags)
 
     def _measurement_key_names_(self) -> FrozenSet[str]:
         return self.all_measurement_key_names()
@@ -161,6 +222,20 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
         except:
             return NotImplemented
 
+    def _repr_args(self) -> str:
+        moments_repr = super()._repr_args()
+        tag_repr = ','.join(_compat.proper_repr(t) for t in self._tags)
+        return f'{moments_repr}, tags=[{tag_repr}]' if self.tags else moments_repr
+
+    def _json_dict_(self):
+        attribute_names = ['moments', 'tags'] if self.tags else ['moments']
+        ret = protocols.obj_to_dict_helper(self, attribute_names)
+        return ret
+
+    @classmethod
+    def _from_json_dict_(cls, moments, *, tags=(), **kwargs):
+        return cls(moments, strategy=InsertStrategy.EARLIEST, tags=tags)
+
     def concat_ragged(
         *circuits: 'cirq.AbstractCircuit', align: Union['cirq.Alignment', str] = Alignment.LEFT
     ) -> 'cirq.FrozenCircuit':

cirq/circuits/frozen_circuit_test.py

@@ -17,25 +17,39 @@ Behavior shared with Circuit is tested with parameters in circuit_test.py.
 """
 
 import pytest
+import sympy
 
 import cirq
 
 
 def test_from_moments():
     a, b, c, d = cirq.LineQubit.range(4)
-    assert cirq.FrozenCircuit.from_moments(
+    moment = cirq.Moment(cirq.Z(a), cirq.Z(b))
+    subcircuit = cirq.FrozenCircuit.from_moments(cirq.X(c), cirq.Y(d))
+    circuit = cirq.FrozenCircuit.from_moments(
+        moment,
+        subcircuit,
         [cirq.X(a), cirq.Y(b)],
         [cirq.X(c)],
         [],
         cirq.Z(d),
         [cirq.measure(a, b, key='ab'), cirq.measure(c, d, key='cd')],
-    ) == cirq.FrozenCircuit(
+    )
+    assert circuit == cirq.FrozenCircuit(
+        cirq.Moment(cirq.Z(a), cirq.Z(b)),
+        cirq.Moment(
+            cirq.CircuitOperation(
+                cirq.FrozenCircuit(cirq.Moment(cirq.X(c)), cirq.Moment(cirq.Y(d)))
+            )
+        ),
         cirq.Moment(cirq.X(a), cirq.Y(b)),
         cirq.Moment(cirq.X(c)),
         cirq.Moment(),
         cirq.Moment(cirq.Z(d)),
         cirq.Moment(cirq.measure(a, b, key='ab'), cirq.measure(c, d, key='cd')),
     )
+    assert circuit[0] is moment
+    assert circuit[1].operations[0].circuit is subcircuit
 
 
 def test_freeze_and_unfreeze():
@@ -74,3 +88,34 @@ def test_immutable():
         match="(can't set attribute)|(property 'moments' of 'FrozenCircuit' object has no setter)",
     ):
         c.moments = (cirq.Moment(cirq.H(q)), cirq.Moment(cirq.X(q)))
+
+
+def test_tagged_circuits():
+    q = cirq.LineQubit(0)
+    ops = [cirq.X(q), cirq.H(q)]
+    tags = [sympy.Symbol("a"), "b"]
+    circuit = cirq.Circuit(ops)
+    frozen_circuit = cirq.FrozenCircuit(ops)
+    tagged_circuit = cirq.FrozenCircuit(ops, tags=tags)
+    # Test equality
+    assert tagged_circuit.tags == tuple(tags)
+    assert circuit == frozen_circuit != tagged_circuit
+    assert cirq.approx_eq(circuit, frozen_circuit)
+    assert cirq.approx_eq(frozen_circuit, tagged_circuit)
+    # Test hash
+    assert hash(frozen_circuit) != hash(tagged_circuit)
+    # Test _repr_ and _json_ round trips.
+    cirq.testing.assert_equivalent_repr(tagged_circuit)
+    cirq.testing.assert_json_roundtrip_works(tagged_circuit)
+    # Test utility methods and constructors
+    assert frozen_circuit.with_tags() is frozen_circuit
+    assert frozen_circuit.with_tags(*tags) == tagged_circuit
+    assert tagged_circuit.with_tags("c") == cirq.FrozenCircuit(ops, tags=[*tags, "c"])
+    assert tagged_circuit.untagged == frozen_circuit
+    assert frozen_circuit.untagged is frozen_circuit
+    # Test parameterized protocols
+    assert cirq.is_parameterized(frozen_circuit) is False
+    assert cirq.is_parameterized(tagged_circuit) is True
+    assert cirq.parameter_names(tagged_circuit) == {"a"}
+    # Tags are not propagated to diagrams yet.
+    assert str(frozen_circuit) == str(tagged_circuit)

cirq/circuits/qasm_output_test.py

@@ -248,18 +248,18 @@ def test_unsupported_operation():
 
 
 def _all_operations(q0, q1, q2, q3, q4, include_measurements=True):
-    class DummyOperation(cirq.Operation):
+    class ExampleOperation(cirq.Operation):
         qubits = (q0,)
         with_qubits = NotImplemented
 
         def _qasm_(self, args: cirq.QasmArgs) -> str:
-            return '// Dummy operation\n'
+            return '// Example operation\n'
 
         def _decompose_(self):
             # Only used by test_output_unitary_same_as_qiskit
-            return ()  # coverage: ignore
+            return ()  # pragma: no cover
 
-    class DummyCompositeOperation(cirq.Operation):
+    class ExampleCompositeOperation(cirq.Operation):
         qubits = (q0,)
         with_qubits = NotImplemented
 
@@ -267,7 +267,7 @@ def _all_operations(q0, q1, q2, q3, q4, include_measurements=True):
             return cirq.X(self.qubits[0])
 
         def __repr__(self):
-            return 'DummyCompositeOperation()'
+            return 'ExampleCompositeOperation()'
 
     return (
         cirq.I(q0),
@@ -328,8 +328,8 @@ def _all_operations(q0, q1, q2, q3, q4, include_measurements=True):
         )
         if include_measurements
         else (),
-        DummyOperation(),
-        DummyCompositeOperation(),
+        ExampleOperation(),
+        ExampleCompositeOperation(),
     )
 
 
@@ -539,9 +539,9 @@ measure q[2] -> m_multi[1];
 x q[2];  // Undo the inversion
 measure q[3] -> m_multi[2];
 
-// Dummy operation
+// Example operation
 
-// Operation: DummyCompositeOperation()
+// Operation: ExampleCompositeOperation()
 x q[0];
 """
     )

cirq/conftest.py

@@ -27,8 +27,7 @@ def pytest_configure(config):
 
 def pytest_pyfunc_call(pyfuncitem):
     if inspect.iscoroutinefunction(pyfuncitem._obj):
-        # coverage: ignore
-        raise ValueError(
+        raise ValueError(  # pragma: no cover
             f'{pyfuncitem._obj.__name__} is a bare async function. '
             f'It should be decorated with "@duet.sync".'
         )

cirq/contrib/acquaintance/devices.py

@@ -68,7 +68,7 @@ class _UnconstrainedAcquaintanceDevice(AcquaintanceDevice):
     """An acquaintance device with no constraints other than of the gate types."""
 
     def __repr__(self) -> str:
-        return 'UnconstrainedAcquaintanceDevice'  # coverage: ignore
+        return 'UnconstrainedAcquaintanceDevice'  # pragma: no cover
 
 
 UnconstrainedAcquaintanceDevice = _UnconstrainedAcquaintanceDevice()

cirq/contrib/hacks/disable_validation_test.py

@@ -29,7 +29,7 @@ def test_disable_op_validation():
     with pytest.raises(ValueError, match='mysterious and terrible'):
         with disable_op_validation():
             # This does not run - the with condition errors out first.
-            _ = cirq.H(q0, q1)  # coverage: ignore
+            _ = cirq.H(q0, q1)  # pragma: no cover
 
     # Passes, skipping validation.
     with disable_op_validation(accept_debug_responsibility=True):

cirq/contrib/noise_models/noise_models.py

@@ -41,8 +41,7 @@ class DepolarizingNoiseModel(devices.NoiseModel):
         self._prepend = prepend
 
     def noisy_moment(self, moment: 'cirq.Moment', system_qubits: Sequence['cirq.Qid']):
-        if validate_all_measurements(moment) or self.is_virtual_moment(moment):
-            # coverage: ignore
+        if validate_all_measurements(moment) or self.is_virtual_moment(moment):  # pragma: no cover
             return moment
 
         output = [

cirq/contrib/paulistring/clifford_optimize.py

@@ -161,7 +161,7 @@ def clifford_optimized_circuit(circuit: circuits.Circuit, atol: float = 1e-8) ->
             else:
                 # Two CZ gates that share one qubit
                 # Pass through and keep looking
-                continue  # coverage: ignore
+                continue  # pragma: no cover
                 # The above line is covered by test_remove_staggered_czs but the
                 # coverage checker disagrees.
         return 0

cirq/contrib/paulistring/clifford_target_gateset_test.py

@@ -182,11 +182,11 @@ def test_already_converted():
 
 
 def test_ignore_unsupported_gate():
-    class UnsupportedDummy(cirq.testing.TwoQubitGate):
+    class UnsupportedGate(cirq.testing.TwoQubitGate):
         pass
 
     q0, q1 = cirq.LineQubit.range(2)
-    c_orig = cirq.Circuit(UnsupportedDummy()(q0, q1), cirq.X(q0) ** sympy.Symbol("theta"))
+    c_orig = cirq.Circuit(UnsupportedGate()(q0, q1), cirq.X(q0) ** sympy.Symbol("theta"))
     c_new = cirq.optimize_for_target_gateset(
         c_orig, gateset=CliffordTargetGateset(), ignore_failures=True
     )
@@ -194,11 +194,11 @@ def test_ignore_unsupported_gate():
 
 
 def test_fail_unsupported_gate():
-    class UnsupportedDummy(cirq.testing.TwoQubitGate):
+    class UnsupportedGate(cirq.testing.TwoQubitGate):
         pass
 
     q0, q1 = cirq.LineQubit.range(2)
-    c_orig = cirq.Circuit(UnsupportedDummy()(q0, q1))
+    c_orig = cirq.Circuit(UnsupportedGate()(q0, q1))
     with pytest.raises(ValueError):
         _ = cirq.optimize_for_target_gateset(
             c_orig, gateset=CliffordTargetGateset(), ignore_failures=False

cirq/contrib/qcircuit/qcircuit_pdf.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# coverage: ignore
+# pragma: no cover
 
 import errno
 import os

cirq/contrib/quimb/density_matrix.py

@@ -106,8 +106,7 @@ def circuit_to_density_matrix_tensors(
         ValueError: If an op is encountered that cannot be converted.
     """
     if qubits is None:
-        # coverage: ignore
-        qubits = sorted(circuit.all_qubits())
+        qubits = sorted(circuit.all_qubits())  # pragma: no cover
     qubits = tuple(qubits)
 
     qubit_frontier: Dict[cirq.Qid, int] = {q: 0 for q in qubits}
@@ -190,7 +189,7 @@ def circuit_to_density_matrix_tensors(
                 )
                 kraus_frontier += 1
             else:
-                raise ValueError(repr(op))  # coverage: ignore
+                raise ValueError(repr(op))  # pragma: no cover
 
             _positions(mi + 1, op.qubits)
     return tensors, qubit_frontier, positions

cirq/contrib/quimb/grid_circuits.py

@@ -54,12 +54,12 @@ def get_grid_moments(
             for col in range(col_start + col_start_offset, col_end + col_end_offset, col_step):
                 node1 = (row, col)
                 if node1 not in problem_graph.nodes:
-                    continue  # coverage: ignore
+                    continue  # pragma: no cover
                 node2 = get_neighbor(row, col)
                 if node2 not in problem_graph.nodes:
-                    continue  # coverage: ignore
+                    continue  # pragma: no cover
                 if (node1, node2) not in problem_graph.edges:
-                    continue  # coverage: ignore
+                    continue  # pragma: no cover
 
                 weight = problem_graph.edges[node1, node2].get('weight', 1)
                 yield two_qubit_gate(exponent=weight, global_shift=-0.5).on(

cirq/contrib/quimb/state_vector.py

@@ -9,7 +9,6 @@ import quimb.tensor as qtn
 import cirq
 
 
-# coverage: ignore
 def _get_quimb_version():
     """Returns the quimb version and parsed (major,minor) numbers if possible.
     Returns:
@@ -18,7 +17,7 @@ def _get_quimb_version():
     version = quimb.__version__
     try:
         return tuple(int(x) for x in version.split('.')), version
-    except:
+    except:  # pragma: no cover
         return (0, 0), version
 
 
@@ -59,7 +58,7 @@ def circuit_to_tensors(
             corresponding to the |0> state.
     """
     if qubits is None:
-        qubits = sorted(circuit.all_qubits())  # coverage: ignore
+        qubits = sorted(circuit.all_qubits())  # pragma: no cover
 
     qubit_frontier = {q: 0 for q in qubits}
     positions = None
@@ -163,8 +162,7 @@ def tensor_expectation_value(
     ]
     tn = qtn.TensorNetwork(tensors + end_bras)
     if QUIMB_VERSION[0] < (1, 3):
-        # coverage: ignore
-        warnings.warn(
+        warnings.warn(  # pragma: no cover
             f'quimb version {QUIMB_VERSION[1]} detected. Please use '
             f'quimb>=1.3 for optimal performance in '
             '`tensor_expectation_value`. '

cirq/contrib/routing/utils.py

@@ -96,8 +96,7 @@ def get_circuit_connectivity(circuit: 'cirq.Circuit') -> nx.Graph:
     for op in circuit.all_operations():
         n_qubits = len(op.qubits)
         if n_qubits > 2:
-            # coverage: ignore
-            raise ValueError(
+            raise ValueError(  # pragma: no cover
                 f"Cannot build a graph out of a circuit that "
                 f"contains {n_qubits}-qubit operations"
             )

cirq/contrib/svg/svg.py

@@ -2,12 +2,14 @@
 from typing import TYPE_CHECKING, List, Tuple, cast, Dict
 
 import matplotlib.textpath
+import matplotlib.font_manager
+
 
 if TYPE_CHECKING:
     import cirq
 
 QBLUE = '#1967d2'
-FONT = "Arial"
+FONT = matplotlib.font_manager.FontProperties(family="Arial")
 EMPTY_MOMENT_COLWIDTH = float(21)  # assumed default column width
 
 
@@ -140,12 +142,11 @@ def _fit_vertical(
     return row_starts, row_heights, yi_map
 
 
-def _debug_spacing(col_starts, row_starts):
+def _debug_spacing(col_starts, row_starts):  # pragma: no cover
     """Return a string suitable for inserting inside an <svg> tag that
     draws green lines where columns and rows start. This is very useful
     if you're developing this code and are debugging spacing issues.
     """
-    # coverage: ignore
     t = ''
     for i, cs in enumerate(col_starts):
         t += (
@@ -198,7 +199,6 @@ def tdd_to_svg(
             # qubits start at far left and their wires shall be blue
             stroke = QBLUE
         else:
-            # coverage: ignore
             stroke = 'black'
         t += f'<line x1="{x1}" x2="{x2}" y1="{y}" y2="{y}" stroke="{stroke}" stroke-width="1" />'
 
@@ -261,11 +261,9 @@ class SVGCircuit:
     """
 
     def __init__(self, circuit: 'cirq.Circuit'):
-        # coverage: ignore
         self.circuit = circuit
 
     def _repr_svg_(self) -> str:
-        # coverage: ignore
         return circuit_to_svg(self.circuit)