replace chr(30) and chr(31) delimiters with k and t

Author: splch

cirq-ionq/cirq_ionq/job.py

@@ -178,16 +178,22 @@ def measurement_dict(self, circuit_index=0) -> dict[str, Sequence[int]]:
                 measurement_matadata = self._job['metadata']
 
             if measurement_matadata is not None:
-                full_str = ''.join(
-                    value
-                    for key, value in measurement_matadata.items()
-                    if key.startswith('measurement')
-                )
-                if full_str == '':
+                pieces = [
+                    (int(k[len("measurement") :]), v)
+                    for k, v in measurement_matadata.items()
+                    if k.startswith("measurement")
+                ]
+                if not pieces:
+                    return measurement_dict
+                pieces.sort(key=lambda kv: kv[0])
+                full_str = "".join(v for _, v in pieces)
+                # JSON encoding: [{"k": str, "t": [int, ...]}, ...]
+                arr = json.loads(full_str)
+                if isinstance(arr, list) and all(isinstance(x, dict) for x in arr):
+                    for item in arr:
+                        if 'k' in item and 't' in item:
+                            measurement_dict[str(item['k'])] = [int(t) for t in item['t']]
                     return measurement_dict
-                for key_value in full_str.split(chr(30)):
-                    key, value = key_value.split(chr(31))
-                    measurement_dict[key] = [int(t) for t in value.split(',')]
 
         return measurement_dict
 

cirq-ionq/cirq_ionq/serializer.py

@@ -407,12 +407,11 @@ def _serialize_measurements(self, meas_ops: Iterator) -> dict[str, str]:
         and targets into a form that is suitable for passing through IonQ's metadata field
         for a job.
 
-        Each key and targets are serialized into a string of the form `key` + the ASCII unit
-        separator (chr(31)) + targets as a comma separated value.  These are then combined
-        into a string with a separator character of the ASCII record separator (chr(30)).
-        Finally this full string is serialized as the values in the metadata dict with keys
-        given by `measurementX` for X = 0,1, .. 9 and X large enough to contain the entire
-        string.
+        Measurements are encoded as a compact JSON array of objects with keys:
+        `{"k": <measurement_key:str>, "t": <list[int] of target qubit indices>}`.
+        The resulting JSON string is split into chunks and stored under
+        `measurement0`, `measurement1`, ... to respect the IonQ metadata
+        value-size limit.
 
         Args:
             A list of the result of serializing the measurement (not supported by the API).
@@ -423,8 +422,13 @@ def _serialize_measurements(self, meas_ops: Iterator) -> dict[str, str]:
         Raises:
             ValueError: if the
         """
-        key_values = [f'{op["key"]}{chr(31)}{op["targets"]}' for op in meas_ops]
-        full_str = chr(30).join(key_values)
+        # Encode as JSON (no control chars) and keep measurement0..N chunking.
+        json_array = [
+            {"k": op["key"], "t": [int(t) for t in op["targets"].split(",")]} for op in meas_ops
+        ]
+        if not json_array:
+            return {}
+        full_str = json.dumps(json_array, separators=(",", ":"))
         # IonQ maximum value size for metadata.
         max_value_size = 40
         split_strs = [