JSON Protocol

cirq/devices/grid_qubit.py

@@ -15,7 +15,7 @@
 
 from typing import Dict, List, Tuple
 
-from cirq import ops
+from cirq import ops, protocols
 
 
 class GridQubit(ops.Qid):
@@ -139,6 +139,9 @@ def __repr__(self):
     def __str__(self):
         return '({}, {})'.format(self.row, self.col)
 
+    def _json_dict_(self):
+        return protocols.to_json_dict(self, ['row', 'col'])
+
     def __add__(self, other: Tuple[int, int]) -> 'GridQubit':
         if not (isinstance(other, tuple) and len(other) == 2 and
                 all(isinstance(x, int) for x in other)):

cirq/devices/grid_qubit_test.py

@@ -167,3 +167,13 @@ def test_from_proto_bad_dict():
         cirq.GridQubit.from_proto_dict({})
     with pytest.raises(ValueError):
         cirq.GridQubit.from_proto_dict({'nothing': 1})
+
+
+def test_to_json():
+    q = cirq.GridQubit(5, 6)
+    d = q._json_dict_()
+    assert d == {
+        'cirq_type': 'GridQubit',
+        'row': 5,
+        'col': 6,
+    }

cirq/line/line_qubit.py

@@ -15,7 +15,7 @@
 import functools
 from typing import List
 
-from cirq import ops
+from cirq import ops, protocols
 
 @functools.total_ordering
 class LineQubit(ops.Qid):
@@ -84,3 +84,6 @@ def __rsub__(self, other: int) -> 'LineQubit':
 
     def __neg__(self) -> 'LineQubit':
         return LineQubit(-self.x)
+
+    def _json_dict_(self):
+        return protocols.to_json_dict(self, ['x'])

cirq/line/line_qubit_test.py

@@ -107,3 +107,10 @@ def test_addition_subtraction_type_error():
 
 def test_neg():
     assert -cirq.LineQubit(1) == cirq.LineQubit(-1)
+
+
+def test_json_dict():
+    assert cirq.LineQubit(5)._json_dict_() == {
+        'cirq_type': 'LineQubit',
+        'x': 5,
+    }

cirq/ops/eigen_gate.py

@@ -108,6 +108,10 @@ def __init__(self, *,  # Forces keyword args.
     def exponent(self) -> Union[sympy.Basic, float]:
         return self._exponent
 
+    @property
+    def global_shift(self) -> float:
+        return self._global_shift
+
     # virtual method
     def _with_exponent(self: TSelf,
                        exponent: Union[sympy.Basic, float]) -> TSelf:
@@ -319,6 +323,9 @@ def _resolve_parameters_(self: TSelf, param_resolver) -> TSelf:
         return self._with_exponent(
                 exponent=param_resolver.value_of(self._exponent))
 
+    def _json_dict_(self):
+        return protocols.to_json_dict(self, ['exponent', 'global_shift'])
+
 
 def _lcm(vals: Iterable[int]) -> int:
     t = 1

cirq/ops/gate_operation.py

@@ -77,6 +77,9 @@ def __str__(self):
         return '{}({})'.format(self.gate,
                                ', '.join(str(e) for e in self.qubits))
 
+    def _json_dict_(self):
+        return protocols.to_json_dict(self, ['gate', 'qubits'])
+
     def _group_interchangeable_qubits(self) -> Tuple[
             Union[raw_types.Qid,
                   Tuple[int, FrozenSet[raw_types.Qid]]],

cirq/protocols/__init__.py

@@ -54,6 +54,9 @@
 from cirq.protocols.inverse import (
     inverse,
 )
+from cirq.protocols.json import (
+    to_json, read_json, to_json_dict
+)
 from cirq.protocols.measurement_key import (
     is_measurement,
     measurement_key,

cirq/protocols/json.py

@@ -0,0 +1,88 @@
+# Copyright 2019 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 string
+import json
+from typing import TYPE_CHECKING, Union, Any, Tuple, TypeVar, Optional, Dict, \
+    Iterable
+
+import numpy as np
+
+from typing_extensions import Protocol
+
+from cirq.type_workarounds import NotImplementedType
+
+TDefault = TypeVar('TDefault')
+
+RaiseTypeErrorIfNotProvided = ([],)  # type: Any
+
+
+class SupportsJSON(Protocol):
+    """An object that can be turned into JSON dictionaries.
+
+    Returning `NotImplemented` or `None` means "don't know how to turn into
+    QASM". In that case fallbacks based on decomposition and known unitaries
+    will be used instead.
+    """
+
+    def _json_dict_(self) -> Union[None, NotImplementedType, Dict[Any, Any]]:
+        pass
+
+
+def to_json_dict(obj, attribute_names):
+    d = {'cirq_type': obj.__class__.__name__}
+    for attr_name in attribute_names:
+        d[attr_name] = getattr(obj, attr_name)
+    return d
+
+
+class CirqEncoder(json.JSONEncoder):
+    def default(self, o):
+        if hasattr(o, '_json_dict_'):
+            return o._json_dict_()
+        if isinstance(o, np.ndarray):
+            return o.tolist()
+        if isinstance(o, np.int_):
+            return o.item()
+        return super().default(o)
+
+
+def cirq_object_hook(d):
+    if 'cirq_type' in d:
+        import cirq
+        cls = getattr(cirq, d['cirq_type'])
+
+        if hasattr(cls, '_from_json_dict_'):
+            return cls._from_json_dict_(**d)
+
+        del d['cirq_type']
+        return cls(**d)
+
+    return d
+
+
+def to_json(obj: Any, file, *, indent=2, cls=CirqEncoder):
+    if isinstance(file, str):
+        with open(file, 'w') as actually_a_file:
+            return json.dump(obj, actually_a_file, indent=indent, cls=cls)
+
+    return json.dump(obj, file, indent=indent, cls=cls)
+
+
+def read_json(file_or_fn, object_hook=cirq_object_hook):
+    if isinstance(file_or_fn, str):
+        with open(file_or_fn, 'r') as file:
+            return json.load(file, object_hook=object_hook)
+
+    return json.load(file_or_fn, object_hook=object_hook)

cirq/protocols/json_test.py

@@ -0,0 +1,99 @@
+# Copyright 2019 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 pytest
+
+import cirq
+import cirq.protocols
+import io
+
+
+def assert_roundtrip(obj, text_should_be=None):
+    buffer = io.StringIO()
+    cirq.protocols.to_json(obj, buffer)
+
+    if text_should_be is not None:
+        buffer.seek(0)
+        text = buffer.read()
+
+        print()
+        print(text)
+
+        assert text == text_should_be
+
+    buffer.seek(0)
+    obj2 = cirq.protocols.read_json(buffer)
+    assert obj == obj2
+
+
+def test_line_qubit_roundtrip():
+    q1 = cirq.LineQubit(12)
+
+    buffer = io.StringIO()
+    cirq.protocols.to_json(q1, buffer)
+
+    buffer.seek(0)
+    text = buffer.read()
+
+    print()
+    print(text)
+
+    assert text == """{
+  "cirq_type": "LineQubit",
+  "x": 12
+}"""
+
+    buffer.seek(0)
+    q2 = cirq.protocols.read_json(buffer)
+    assert q1 == q2
+
+
+def test_op_roundtrip():
+    q = cirq.LineQubit(5)
+    op1 = cirq.Rx(.123).on(q)
+
+    buffer = io.StringIO()
+    cirq.protocols.to_json(op1, buffer)
+
+    buffer.seek(0)
+    text = buffer.read()
+    assert text == """{
+  "cirq_type": "GateOperation",
+  "gate": {
+    "cirq_type": "XPowGate",
+    "exponent": 0.03915211600060625,
+    "global_shift": -0.5
+  },
+  "qubits": [
+    {
+      "cirq_type": "LineQubit",
+      "x": 5
+    }
+  ]
+}"""
+
+    print()
+    print(text)
+
+    buffer.seek(0)
+    op2 = cirq.protocols.read_json(buffer)
+    assert op1 == op2
+
+
+def test_gridqubit_roundtrip():
+    q = cirq.GridQubit(15, 18)
+    assert_roundtrip(q, text_should_be="""{
+  "cirq_type": "GridQubit",
+  "row": 15,
+  "col": 18
+}""")