remove python stuff

Author: petrelharp

python/tests/test_metadata.py

@@ -671,51 +671,6 @@ def test_round_trip_with_struct_and_json(self):
         out = ms.decode_row(encoded)
         assert out == row
 
-    def test_blob_bytes_aligned(self):
-        # test that the portion of the encoded metadata up until the struct
-        # is 8-byte aligned; we do that in the pedantic way
-        # of figuring out how much memory is being used per int
-        # in the struct part and subtracting that off
-        def schema_with_blobs(k):
-            schema = {
-                "codec": "json+struct",
-                "json": {
-                    "type": "object",
-                    "properties": {
-                        "label": {"type": "string"},
-                        "count": {"type": "number"},
-                    },
-                    "required": ["label"],
-                },
-                "struct": {
-                    "type": "object",
-                    "properties": {},
-                },
-            }
-            for j in range(k):
-                schema["struct"]["properties"][f"b{j}"] = {
-                    "type": "integer",
-                    "binaryFormat": "i",
-                }
-            return tskit.MetadataSchema(schema)
-
-        k_list = (0, 1, 2, 3)
-        schemas = [schema_with_blobs(k) for k in k_list]
-        rows = []
-        for k in k_list:
-            row = {"label": "alpha", "count": 7}
-            for j in range(k):
-                row[f"b{j}"] = j
-            rows.append(row)
-        encoded = [ms.validate_and_encode_row(row) for ms, row in zip(schemas, rows)]
-        dbytes = len(encoded[2]) - len(encoded[1])
-        assert len(encoded[3]) - len(encoded[2]) == dbytes
-        for k, en in zip(k_list, encoded):
-            assert (len(en) - k * dbytes) % 8 == 0
-        for ms, en, row in zip(schemas, encoded, rows):
-            decoded = ms.decode_row(en)
-            assert decoded == row
-
     def test_json_defaults_applied(self):
         schema = {
             "codec": "json+struct",

python/tskit/metadata.py

@@ -201,12 +201,6 @@ class JSONStructCodec(AbstractMetadataCodec):
     The codec expects a metadata schema with separate ``json`` and ``struct``
     subschemas and produces a single dict containing the union of the keys from
     those subschemas after decoding.
-
-    The structure of the encoded metadata is as follows: first, a fixed-size
-    header that contains the number of bytes for both ``json`` and ``struct``
-    portions; next, the json; then a variable number of zeroed padding bytes
-    that brings the length to a multiple of 8 for alignment; and finally
-    the struct-encoded binary portion.
     """
 
     MAGIC = b"JBLB"
@@ -300,25 +294,20 @@ def encode(self, obj: Any) -> bytes:
         header = self._HDR.pack(
             self.MAGIC, self.VERSION, len(json_bytes), len(blob_bytes)
         )
-        padding_bytes = bytes((-(len(header) + len(json_bytes))) % 8)
-        return header + json_bytes + padding_bytes + blob_bytes
+        return header + json_bytes + blob_bytes
 
     def decode(self, encoded: bytes) -> Any:
         if len(encoded) >= self._HDR.size and encoded[:4] == self.MAGIC:
             _, version, jlen, blen = self._HDR.unpack_from(encoded)
             if version != self.VERSION:
                 raise ValueError("Unsupported json+struct version")
             start = self._HDR.size
-            padding_length = (-(start + jlen)) % 8
-            if (
-                jlen > len(encoded) - start
-                or blen > len(encoded) - start - jlen - padding_length
-            ):
+            if jlen > len(encoded) - start or blen > len(encoded) - start - jlen:
                 raise ValueError(
                     "Invalid json+struct payload: declared lengths exceed buffer size"
                 )
             json_bytes = encoded[start : start + jlen]
-            blob_bytes = encoded[start + jlen : start + jlen + blen + padding_length]
+            blob_bytes = encoded[start + jlen : start + jlen + blen]
             json_data = self.json_codec.decode(json_bytes)
             struct_data = self.struct_codec.decode(blob_bytes)
             overlap = set(json_data).intersection(struct_data)