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

cirq/contrib/graph_device/graph_device_test.py

@@ -12,6 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
+from typing import Any, Hashable, Iterable
+
 import pytest
 
 import cirq
@@ -19,7 +23,7 @@ import cirq.contrib.graph_device as ccgd
 import cirq.contrib.graph_device.graph_device as ccgdgd
 
 
-def test_fixed_duration_undirected_graph_device_edge_eq():
+def test_fixed_duration_undirected_graph_device_edge_eq() -> None:
     e = ccgd.FixedDurationUndirectedGraphDeviceEdge(cirq.Duration(picos=4))
     f = ccgd.FixedDurationUndirectedGraphDeviceEdge(cirq.Duration(picos=4))
     g = ccgd.FixedDurationUndirectedGraphDeviceEdge(cirq.Duration(picos=5))
@@ -28,15 +32,15 @@ def test_fixed_duration_undirected_graph_device_edge_eq():
     assert e != 4
 
 
-def test_unconstrained_undirected_graph_device_edge_eq():
+def test_unconstrained_undirected_graph_device_edge_eq() -> None:
     e = ccgdgd._UnconstrainedUndirectedGraphDeviceEdge()
     f = ccgd.UnconstrainedUndirectedGraphDeviceEdge
     assert e == f
     assert e != 3
 
 
-def test_is_undirected_device_graph():
-    assert not ccgd.is_undirected_device_graph('abc')
+def test_is_undirected_device_graph() -> None:
+    assert not ccgd.is_undirected_device_graph('abc')  # type: ignore[arg-type]
     graph = ccgd.UndirectedHypergraph()
     assert ccgd.is_undirected_device_graph(graph)
     a, b, c, d, e = cirq.LineQubit.range(5)
@@ -50,9 +54,9 @@ def test_is_undirected_device_graph():
     assert not ccgd.is_undirected_device_graph(graph)
 
 
-def test_is_crosstalk_graph():
+def test_is_crosstalk_graph() -> None:
     a, b, c, d, e, f = cirq.LineQubit.range(6)
-    assert not ccgd.is_crosstalk_graph('abc')
+    assert not ccgd.is_crosstalk_graph('abc')  # type: ignore[arg-type]
     graph = ccgd.UndirectedHypergraph()
     graph.add_vertex('abc')
     assert not ccgd.is_crosstalk_graph(graph)
@@ -74,14 +78,14 @@ def test_is_crosstalk_graph():
     assert not ccgd.is_crosstalk_graph(graph)
 
 
-def test_unconstrained_undirected_graph_device_edge():
+def test_unconstrained_undirected_graph_device_edge() -> None:
     edge = ccgd.UnconstrainedUndirectedGraphDeviceEdge
     qubits = cirq.LineQubit.range(2)
     assert edge.duration_of(cirq.X(qubits[0])) == cirq.Duration(picos=0)
     assert edge.duration_of(cirq.CZ(*qubits[:2])) == cirq.Duration(picos=0)
 
 
-def test_graph_device():
+def test_graph_device() -> None:
     one_qubit_duration = cirq.Duration(picos=10)
     two_qubit_duration = cirq.Duration(picos=1)
     one_qubit_edge = ccgd.FixedDurationUndirectedGraphDeviceEdge(one_qubit_duration)
@@ -93,7 +97,7 @@ def test_graph_device():
 
     n_qubits = 4
     qubits = cirq.LineQubit.range(n_qubits)
-    edges = {
+    edges: dict[Iterable[Hashable], Any] = {
         (cirq.LineQubit(i), cirq.LineQubit((i + 1) % n_qubits)): two_qubit_edge
         for i in range(n_qubits)
     }
@@ -109,8 +113,8 @@ def test_graph_device():
 
     assert ccgd.is_undirected_device_graph(device_graph)
     with pytest.raises(TypeError):
-        ccgd.UndirectedGraphDevice('abc')
-    constraint_edges = {
+        ccgd.UndirectedGraphDevice('abc')  # type: ignore[arg-type]
+    constraint_edges: dict[Iterable[Hashable], Any] = {
         (frozenset(cirq.LineQubit.range(2)), frozenset(cirq.LineQubit.range(2, 4))): None,
         (
             frozenset(cirq.LineQubit.range(1, 3)),
@@ -121,7 +125,7 @@ def test_graph_device():
     assert ccgd.is_crosstalk_graph(crosstalk_graph)
 
     with pytest.raises(TypeError):
-        ccgd.UndirectedGraphDevice(device_graph, crosstalk_graph='abc')
+        ccgd.UndirectedGraphDevice(device_graph, crosstalk_graph='abc')  # type: ignore[arg-type]
 
     graph_device = ccgd.UndirectedGraphDevice(device_graph)
     assert graph_device.crosstalk_graph == ccgd.UndirectedHypergraph()
@@ -139,7 +143,7 @@ def test_graph_device():
     with pytest.raises(ValueError):
         graph_device.validate_operation(cirq.CNOT(qubits[0], qubits[2]))
     with pytest.raises(AttributeError):
-        graph_device.validate_operation(list((2, 3)))
+        graph_device.validate_operation(list((2, 3)))  # type: ignore[arg-type]
 
     moment = cirq.Moment([cirq.CNOT(*qubits[:2]), cirq.CNOT(*qubits[2:])])
     with pytest.raises(ValueError):
@@ -153,7 +157,7 @@ def test_graph_device():
         graph_device.validate_moment(moment)
 
 
-def test_graph_device_copy_and_add():
+def test_graph_device_copy_and_add() -> None:
     a, b, c, d, e, f = cirq.LineQubit.range(6)
     device_graph = ccgd.UndirectedHypergraph(labelled_edges={(a, b): None, (c, d): None})
     crosstalk_graph = ccgd.UndirectedHypergraph(

cirq/contrib/graph_device/hypergraph.py

@@ -12,19 +12,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import itertools
 import random
-from typing import Any, Dict, FrozenSet, Hashable, Iterable, Mapping, Optional, Set, Tuple, Union
+from typing import Any, Hashable, Iterable, Mapping
 
-AdjacencyList = Set[FrozenSet[Hashable]]
+AdjacencyList = set[frozenset[Hashable]]
 
 
 class UndirectedHypergraph:
     def __init__(
         self,
         *,
-        vertices: Optional[Iterable[Hashable]] = None,
-        labelled_edges: Optional[Dict[Iterable[Hashable], Any]] = None,
+        vertices: Iterable[Hashable] | None = None,
+        labelled_edges: dict[Iterable[Hashable], Any] | None = None,
     ) -> None:
         """A labelled, undirected hypergraph.
 
@@ -35,23 +37,23 @@ class UndirectedHypergraph:
                 automatically added.
         """
 
-        self._adjacency_lists: Dict[Hashable, AdjacencyList] = {}
-        self._labelled_edges: Dict[FrozenSet[Hashable], Any] = {}
+        self._adjacency_lists: dict[Hashable, AdjacencyList] = {}
+        self._labelled_edges: dict[frozenset[Hashable], Any] = {}
         if vertices is not None:
             self.add_vertices(vertices)
         if labelled_edges is not None:
             self.add_edges(labelled_edges)
 
     @property
-    def vertices(self) -> Tuple[Hashable, ...]:
+    def vertices(self) -> tuple[Hashable, ...]:
         return tuple(self._adjacency_lists.keys())
 
     @property
-    def edges(self) -> Tuple[FrozenSet[Hashable], ...]:
+    def edges(self) -> tuple[frozenset[Hashable], ...]:
         return tuple(self._labelled_edges.keys())
 
     @property
-    def labelled_edges(self) -> Dict[FrozenSet, Any]:
+    def labelled_edges(self) -> dict[frozenset, Any]:
         return dict(self._labelled_edges)
 
     def add_vertex(self, vertex: Hashable) -> None:
@@ -69,7 +71,7 @@ class UndirectedHypergraph:
                 self._adjacency_lists[neighbor].difference_update((edge,))
         del self._adjacency_lists[vertex]
 
-    def remove_vertices(self, vertices):
+    def remove_vertices(self, vertices) -> None:
         for vertex in vertices:
             self.remove_vertex(vertex)
 
@@ -80,7 +82,7 @@ class UndirectedHypergraph:
             self._adjacency_lists[vertex].update((vertices,))
         self._labelled_edges[vertices] = label
 
-    def add_edges(self, edges: Dict[Iterable[Hashable], Any]):
+    def add_edges(self, edges: dict[Iterable[Hashable], Any]) -> None:
         for vertices, label in edges.items():
             self.add_edge(vertices, label)
 
@@ -102,8 +104,8 @@ class UndirectedHypergraph:
 
     @classmethod
     def random(
-        cls, vertices: Union[int, Iterable], edge_probs: Mapping[int, float]
-    ) -> 'UndirectedHypergraph':
+        cls, vertices: int | Iterable, edge_probs: Mapping[int, float]
+    ) -> UndirectedHypergraph:
         """A random hypergraph.
 
         Every possible edge is included with probability edge_prob[len(edge)].
@@ -125,5 +127,5 @@ class UndirectedHypergraph:
             for potential_edge in itertools.combinations(vertices, edge_size):
                 if random.random() < edge_prob:
                     edges.append(potential_edge)
-        labelled_edges: Dict[Iterable[Hashable], Any] = {edge: None for edge in edges}
+        labelled_edges: dict[Iterable[Hashable], Any] = {edge: None for edge in edges}
         return cls(vertices=vertices, labelled_edges=labelled_edges)

cirq/contrib/graph_device/hypergraph_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 random
 
 import pytest
@@ -19,7 +21,7 @@ import pytest
 import cirq.contrib.graph_device as ccgd
 
 
-def test_update_edge_label():
+def test_update_edge_label() -> None:
     edge = frozenset(range(3))
     graph = ccgd.UndirectedHypergraph(labelled_edges={edge: 'a'})
     assert graph.labelled_edges[edge] == 'a'
@@ -27,7 +29,7 @@ def test_update_edge_label():
     assert graph.labelled_edges[edge] == 'b'
 
 
-def test_hypergraph():
+def test_hypergraph() -> None:
     vertices = range(4)
     graph = ccgd.UndirectedHypergraph(vertices=vertices)
     assert graph.vertices == tuple(vertices)
@@ -53,7 +55,7 @@ def test_hypergraph():
         for _ in range(10)
     ],
 )
-def test_eq(vertices, edges):
+def test_eq(vertices, edges) -> None:
     vertices = set(vertices).union(*edges)
     graph_initialized = ccgd.UndirectedHypergraph(vertices=vertices, labelled_edges=edges)
     graph_added_parallel = ccgd.UndirectedHypergraph()
@@ -67,15 +69,15 @@ def test_eq(vertices, edges):
     assert graph_initialized == graph_added_parallel == graph_added_sequential
 
 
-def test_random_hypergraph():
+def test_random_hypergraph() -> None:
     n_vertices = 4
     graph = ccgd.UndirectedHypergraph.random(n_vertices, {1: 1.0})
-    assert sorted(graph.vertices) == sorted(range(n_vertices))
+    assert sorted(graph.vertices) == sorted(range(n_vertices))  # type: ignore[type-var]
     assert set(graph.labelled_edges.values()) == set((None,))
     assert tuple(len(edge) for edge in graph.edges) == (1,) * n_vertices
 
 
-def test_copy():
+def test_copy() -> None:
     graph_original = ccgd.UndirectedHypergraph(labelled_edges={(0, 1): None})
     graph_copy = graph_original.__copy__()
     assert graph_copy == graph_original
@@ -83,20 +85,20 @@ def test_copy():
     assert graph_copy != graph_original
 
 
-def test_iadd():
+def test_iadd() -> None:
     graph = ccgd.UndirectedHypergraph(labelled_edges={(0, 1): None})
     addend = ccgd.UndirectedHypergraph(labelled_edges={(1, 2): None})
     graph += addend
     assert set(graph.edges) == set(frozenset(e) for e in ((0, 1), (1, 2)))
-    assert sorted(graph.vertices) == [0, 1, 2]
+    assert sorted(graph.vertices) == [0, 1, 2]  # type: ignore[type-var]
 
 
-def test_add():
+def test_add() -> None:
     first_addend = ccgd.UndirectedHypergraph(labelled_edges={('a', 'b'): None})
     second_addend = ccgd.UndirectedHypergraph(labelled_edges={('c', 'b'): None})
     graph_sum = first_addend + second_addend
-    assert sorted(first_addend.vertices) == list('ab')
-    assert sorted(second_addend.vertices) == list('bc')
+    assert sorted(first_addend.vertices) == list('ab')  # type: ignore[type-var]
+    assert sorted(second_addend.vertices) == list('bc')  # type: ignore[type-var]
     assert sorted(graph_sum.vertices) == list('abc')
     assert sorted(first_addend.edges) == [frozenset('ab')]
     assert sorted(second_addend.edges) == [frozenset('bc')]

cirq/contrib/graph_device/uniform_graph_device.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Dict, Hashable, Iterable, Mapping, Optional
+from __future__ import annotations
+
+from typing import Any, Hashable, Iterable, Mapping
 
 from cirq import devices, ops
 from cirq.contrib.graph_device.graph_device import UndirectedGraphDevice, UndirectedGraphDeviceEdge
@@ -20,7 +22,7 @@ from cirq.contrib.graph_device.hypergraph import UndirectedHypergraph
 
 
 def uniform_undirected_graph_device(
-    edges: Iterable[Iterable[ops.Qid]], edge_label: Optional[UndirectedGraphDeviceEdge] = None
+    edges: Iterable[Iterable[ops.Qid]], edge_label: UndirectedGraphDeviceEdge | None = None
 ) -> UndirectedGraphDevice:
     """An undirected graph device all of whose edges are the same.
 
@@ -29,13 +31,13 @@ def uniform_undirected_graph_device(
         edge_label: The label to apply to all edges. Defaults to None.
     """
 
-    labelled_edges: Dict[Iterable[Hashable], Any] = {frozenset(edge): edge_label for edge in edges}
+    labelled_edges: dict[Iterable[Hashable], Any] = {frozenset(edge): edge_label for edge in edges}
     device_graph = UndirectedHypergraph(labelled_edges=labelled_edges)
     return UndirectedGraphDevice(device_graph=device_graph)
 
 
 def uniform_undirected_linear_device(
-    n_qubits: int, edge_labels: Mapping[int, Optional[UndirectedGraphDeviceEdge]]
+    n_qubits: int, edge_labels: Mapping[int, UndirectedGraphDeviceEdge | None]
 ) -> UndirectedGraphDevice:
     """A uniform , undirected graph device whose qubits are arranged
     on a line.

cirq/contrib/graph_device/uniform_graph_device_test.py

@@ -12,21 +12,29 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 import pytest
 
 import cirq
 import cirq.contrib.graph_device as ccgd
 
+if TYPE_CHECKING:
+    from cirq.contrib.graph_device.graph_device import UndirectedGraphDeviceEdge
+
 
-def test_empty_uniform_undirected_linear_device():
+def test_empty_uniform_undirected_linear_device() -> None:
     n_qubits = 4
+    edge_labels: dict[int, UndirectedGraphDeviceEdge | None]
     edge_labels = {}
     device = ccgd.uniform_undirected_linear_device(n_qubits, edge_labels)
     assert device.qubits == tuple()
     assert device.edges == tuple()
 
 
-def test_negative_arity_arg_uniform_undirected_linear_device():
+def test_negative_arity_arg_uniform_undirected_linear_device() -> None:
     with pytest.raises(ValueError):
         ccgd.uniform_undirected_linear_device(5, {-1: None})
     with pytest.raises(ValueError):
@@ -34,7 +42,7 @@ def test_negative_arity_arg_uniform_undirected_linear_device():
 
 
 @pytest.mark.parametrize('arity', range(1, 5))
-def test_regular_uniform_undirected_linear_device(arity):
+def test_regular_uniform_undirected_linear_device(arity) -> None:
     n_qubits = 10
     edge_labels = {arity: None}
     device = ccgd.uniform_undirected_linear_device(n_qubits, edge_labels)

cirq/contrib/hacks/disable_validation.py

@@ -14,11 +14,16 @@
 
 """Tools for disabling validation in circuit construction."""
 
+from __future__ import annotations
+
 import contextlib
+from collections.abc import Generator
 
 
 @contextlib.contextmanager
-def disable_op_validation(*, accept_debug_responsibility: bool = False):
+def disable_op_validation(
+    *, accept_debug_responsibility: bool = False
+) -> Generator[None, None, None]:
     if not accept_debug_responsibility:
         raise ValueError(
             "WARNING! Using disable_op_validation with invalid ops can cause "

cirq/contrib/hacks/disable_validation_test.py

@@ -12,13 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import pytest
 
 import cirq
 from cirq.contrib.hacks.disable_validation import disable_op_validation
 
 
-def test_disable_op_validation():
+def test_disable_op_validation() -> None:
     q0, q1 = cirq.LineQubit.range(2)
 
     # Fails normally.

cirq/contrib/json.py

@@ -1,18 +1,44 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
 """Functions for JSON serialization and de-serialization for classes in Contrib."""
 
-from cirq.protocols.json_serialization import DEFAULT_RESOLVERS
+from __future__ import annotations
 
+import functools
 
-def contrib_class_resolver(cirq_type: str):
+from cirq.protocols.json_serialization import _register_resolver, DEFAULT_RESOLVERS, ObjectFactory
+
+
+def contrib_class_resolver(cirq_type: str) -> ObjectFactory | None:
     """Extend cirq's JSON API with resolvers for cirq contrib classes."""
+    return _class_resolver_dictionary().get(cirq_type, None)
+
+
+@functools.cache
+def _class_resolver_dictionary() -> dict[str, ObjectFactory]:
     from cirq.contrib.acquaintance import SwapPermutationGate
     from cirq.contrib.bayesian_network import BayesianNetworkGate
+    from cirq.contrib.noise_models import (
+        DampedReadoutNoiseModel,
+        DepolarizingNoiseModel,
+        DepolarizingWithDampedReadoutNoiseModel,
+        DepolarizingWithReadoutNoiseModel,
+        ReadoutNoiseModel,
+    )
     from cirq.contrib.quantum_volume import QuantumVolumeResult
 
-    classes = [BayesianNetworkGate, QuantumVolumeResult, SwapPermutationGate]
-    d = {cls.__name__: cls for cls in classes}
-    return d.get(cirq_type, None)
+    classes = [
+        BayesianNetworkGate,
+        QuantumVolumeResult,
+        SwapPermutationGate,
+        DepolarizingNoiseModel,
+        ReadoutNoiseModel,
+        DampedReadoutNoiseModel,
+        DepolarizingWithReadoutNoiseModel,
+        DepolarizingWithDampedReadoutNoiseModel,
+    ]
+    return {cls.__name__: cls for cls in classes}
 
 
 DEFAULT_CONTRIB_RESOLVERS = [contrib_class_resolver] + DEFAULT_RESOLVERS
+
+_register_resolver(_class_resolver_dictionary)

cirq/contrib/json_test.py

@@ -1,4 +1,7 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
+
+from __future__ import annotations
+
 import cirq
 from cirq.contrib.acquaintance import SwapPermutationGate
 from cirq.contrib.bayesian_network import BayesianNetworkGate
@@ -7,14 +10,14 @@ from cirq.contrib.quantum_volume import QuantumVolumeResult
 from cirq.testing import assert_json_roundtrip_works
 
 
-def test_bayesian_network_gate():
+def test_bayesian_network_gate() -> None:
     gate = BayesianNetworkGate(
         init_probs=[('q0', 0.125), ('q1', None)], arc_probs=[('q1', ('q0',), [0.25, 0.5])]
     )
     assert_json_roundtrip_works(gate, resolvers=DEFAULT_CONTRIB_RESOLVERS)
 
 
-def test_quantum_volume():
+def test_quantum_volume() -> None:
     qubits = cirq.LineQubit.range(5)
     qvr = QuantumVolumeResult(
         model_circuit=cirq.Circuit(cirq.H.on_each(qubits)),
@@ -25,6 +28,6 @@ def test_quantum_volume():
     assert_json_roundtrip_works(qvr, resolvers=DEFAULT_CONTRIB_RESOLVERS)
 
 
-def test_swap_permutation_gate():
+def test_swap_permutation_gate() -> None:
     gate = SwapPermutationGate(swap_gate=cirq.SWAP)
     assert_json_roundtrip_works(gate, resolvers=DEFAULT_CONTRIB_RESOLVERS)

cirq/contrib/json_test_data/DampedReadoutNoiseModel.json

@@ -0,0 +1,12 @@
+[
+  {
+    "cirq_type": "DampedReadoutNoiseModel",
+    "decay_prob": 0.3,
+    "prepend": true
+  },
+  {
+    "cirq_type": "DampedReadoutNoiseModel",
+    "decay_prob": 0.4,
+    "prepend": false
+  }
+]

cirq/contrib/json_test_data/DampedReadoutNoiseModel.repr

@@ -0,0 +1,4 @@
+[
+    cirq.contrib.noise_models.DampedReadoutNoiseModel(0.3, prepend=True),
+    cirq.contrib.noise_models.DampedReadoutNoiseModel(0.4, prepend=False),
+]

cirq/contrib/json_test_data/DepolarizingNoiseModel.json

@@ -0,0 +1,12 @@
+[
+  {
+    "cirq_type": "DepolarizingNoiseModel",
+    "depol_prob": 0.1,
+    "prepend": false
+  },
+  {
+    "cirq_type": "DepolarizingNoiseModel",
+    "depol_prob": 0.15,
+    "prepend": true
+  }
+]

cirq/contrib/json_test_data/DepolarizingNoiseModel.repr

@@ -0,0 +1,4 @@
+[
+    cirq.contrib.noise_models.DepolarizingNoiseModel(0.1, prepend=False),
+    cirq.contrib.noise_models.DepolarizingNoiseModel(0.15, prepend=True),
+]

cirq/contrib/json_test_data/DepolarizingWithDampedReadoutNoiseModel.json

@@ -0,0 +1,6 @@
+{
+  "cirq_type": "DepolarizingWithDampedReadoutNoiseModel",
+  "depol_prob": 0.1,
+  "bitflip_prob": 0.2,
+  "decay_prob": 0.3
+}

cirq/contrib/json_test_data/DepolarizingWithDampedReadoutNoiseModel.repr

@@ -0,0 +1 @@
+cirq.contrib.noise_models.DepolarizingWithDampedReadoutNoiseModel(0.1, 0.2, 0.3)

cirq/contrib/json_test_data/DepolarizingWithReadoutNoiseModel.json

@@ -0,0 +1,5 @@
+{
+  "cirq_type": "DepolarizingWithReadoutNoiseModel",
+  "depol_prob": 0.1,
+  "bitflip_prob": 0.2
+}

cirq/contrib/json_test_data/DepolarizingWithReadoutNoiseModel.repr

@@ -0,0 +1 @@
+cirq.contrib.noise_models.DepolarizingWithReadoutNoiseModel(0.1, 0.2)

cirq/contrib/json_test_data/ReadoutNoiseModel.json

@@ -0,0 +1,12 @@
+[
+  {
+    "cirq_type": "ReadoutNoiseModel",
+    "bitflip_prob": 0.2,
+    "prepend": true
+  },
+  {
+    "cirq_type": "ReadoutNoiseModel",
+    "bitflip_prob": 0.23,
+    "prepend": false
+  }
+]

cirq/contrib/json_test_data/ReadoutNoiseModel.repr

@@ -0,0 +1,4 @@
+[
+    cirq.contrib.noise_models.ReadoutNoiseModel(0.2, prepend=True),
+    cirq.contrib.noise_models.ReadoutNoiseModel(0.23, prepend=False),
+]

cirq/contrib/json_test_data/__init__.py

@@ -0,0 +1,17 @@
+# Copyright 2025 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.
+
+"""Test data for JSON serialization of :mod:`cirq.contrib` objects."""
+
+from cirq.contrib.json_test_data.spec import TestSpec as TestSpec

cirq/contrib/json_test_data/spec.py

@@ -0,0 +1,32 @@
+# Copyright 2025 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.
+
+
+import pathlib
+
+import cirq
+from cirq.contrib.json import _class_resolver_dictionary
+from cirq.testing.json import ModuleJsonTestSpec
+
+TestSpec = ModuleJsonTestSpec(
+    name="cirq.contrib",
+    packages=[cirq.contrib],
+    test_data_path=pathlib.Path(__file__).parent,
+    not_yet_serializable=[],
+    should_not_be_serialized=["Unique", "CircuitDag"],
+    resolver_cache=_class_resolver_dictionary(),
+    deprecated={},
+    # TODO: #7520 - create .json and .repr for these so they can be tested here
+    tested_elsewhere=["QuantumVolumeResult", "SwapPermutationGate", "BayesianNetworkGate"],
+)