jamcodec 0.1.5__tar.gz → 0.1.7__tar.gz

{jamcodec-0.1.5 → jamcodec-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jamcodec
-Version: 0.1.5
+Version: 0.1.7
 Summary: Python JAM Codec Library
 Author-email: JAMdot Technologies <dev@jamdot.tech>
 Project-URL: Homepage, https://github.com/JAMdotTech/py-jam-codec

{jamcodec-0.1.5 → jamcodec-0.1.7}/jamcodec/mixins.py

@@ -6,7 +6,7 @@ import typing
 import json
 
 from jamcodec.base import JamCodecTypeDef, JamCodecType, JamBytes
-from jamcodec.types import Struct, Option, Vec, Enum
+from jamcodec.types import Struct, StructObject, Option, Vec, Enum
 
 T = TypeVar('T')
 
@@ -69,6 +69,10 @@ class Serializable:
 
     def to_jam_bytes(self) -> JamBytes:
         scale_obj = self.to_codec_type()
+        if type(scale_obj) in (JamCodecType, StructObject):
+            # The value is already normalized; only the encoded bytes are needed.
+            return scale_obj.type_def.encode(scale_obj.value_serialized)
+        # Preserve encoding and validation hooks on custom codec wrappers.
         return scale_obj.encode()
 
     @classmethod

{jamcodec-0.1.5 → jamcodec-0.1.7}/jamcodec/types.py

@@ -197,18 +197,18 @@ class Struct(JamCodecTypeDef):
 
     def encode(self, value: dict) -> JamBytes:
 
-        data = JamBytes(bytearray())
+        data = bytearray()
         for name, scale_obj in self.arguments.items():
 
             if name not in value:
                 raise ScaleEncodeException(f'Argument "{name}" of Struct is missing in given value')
 
-            data += scale_obj.encode(value[name])
+            data.extend(scale_obj.encode(value[name]).data)
 
             if value[name] and issubclass(value[name].__class__, JamCodecType):
                 value[name] = value[name].serialize()
 
-        return data
+        return JamBytes(data)
 
     def decode(self, data) -> dict:
         value = {}
@@ -277,11 +277,11 @@ class Tuple(JamCodecTypeDef):
         if type(value) is not tuple:
             value = (value,)
 
-        data = JamBytes(bytearray())
+        data = bytearray()
         for idx, scale_obj in enumerate(self.values):
 
-            data += scale_obj.encode(value[idx])
-        return data
+            data.extend(scale_obj.encode(value[idx]).data)
+        return JamBytes(data)
 
     def decode(self, data: JamBytes) -> tuple:
         value = ()
@@ -615,17 +615,17 @@ class Vec(JamCodecTypeDef):
             return Bytes.encode(value)
 
         # Encode length of Vec
-        data = VarInt64.encode(len(value))
+        data = VarInt64.encode(len(value)).data
 
         for idx, item in enumerate(value):
             if type(item) is JamBytes:
-                data += item
+                data.extend(item.data)
             else:
-                data += self.type_def.encode(item)
+                data.extend(self.type_def.encode(item).data)
                 if item and issubclass(item.__class__, JamCodecType):
                     value[idx] = item.serialize()
 
-        return data
+        return JamBytes(data)
 
     def decode(self, data: JamBytes) -> Union[list, bytes]:
 
@@ -823,7 +823,7 @@ class Array(JamCodecTypeDef):
 
             return JamBytes(value)
         else:
-            data = JamBytes(bytearray())
+            data = bytearray()
 
             if type(value) is not list:
                 raise ScaleEncodeException("Value must be of type list")
@@ -832,9 +832,9 @@ class Array(JamCodecTypeDef):
                 raise ScaleEncodeException("Length of list does not match size of array")
 
             for item in value:
-                data += self.type_def.encode(item)
+                data.extend(self.type_def.encode(item).data)
 
-            return data
+            return JamBytes(data)
 
     def decode(self, data: JamBytes) -> Union[list, bytes]:
         if self.type_def is U8:
@@ -1042,13 +1042,13 @@ class Map(JamCodecTypeDef):
         value = sorted(value)
 
         # Encode length of Vec
-        data = VarInt64.encode(len(value))
+        data = VarInt64.encode(len(value)).data
 
         for item_key, item_value in value:
-            data += self.key_def.encode(item_key)
-            data += self.value_def.encode(item_value)
+            data.extend(self.key_def.encode(item_key).data)
+            data.extend(self.value_def.encode(item_value).data)
 
-        return data
+        return JamBytes(data)
 
     def decode(self, data: JamBytes) -> list:
         # Decode length of Map

{jamcodec-0.1.5 → jamcodec-0.1.7}/jamcodec.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jamcodec
-Version: 0.1.5
+Version: 0.1.7
 Summary: Python JAM Codec Library
 Author-email: JAMdot Technologies <dev@jamdot.tech>
 Project-URL: Homepage, https://github.com/JAMdotTech/py-jam-codec

{jamcodec-0.1.5 → jamcodec-0.1.7}/jamcodec.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ test/test_bitvec.py
 test/test_boolean.py
 test/test_bounded_vec.py
 test/test_bytes.py
+test/test_collection_buffers.py
 test/test_compact.py
 test/test_enum.py
 test/test_float.py

jamcodec-0.1.7/test/test_collection_buffers.py

@@ -0,0 +1,35 @@
+import pytest
+
+from jamcodec.base import JamBytes
+from jamcodec.types import Array, Map, Struct, Tuple, U16, Vec
+
+
+@pytest.mark.parametrize("codec,value,expected", [
+    (Struct(first=U16, second=U16), {"first": 1, "second": 2}, b"\x01\x00\x02\x00"),
+    (Tuple(U16, U16), (1, 2), b"\x01\x00\x02\x00"),
+    (Array(U16, 2), [1, 2], b"\x01\x00\x02\x00"),
+    (Vec(U16), [1, 2], b"\x02\x01\x00\x02\x00"),
+    (Map(U16, U16), {2: 1, 1: 2}, b"\x02\x01\x00\x02\x00\x02\x00\x01\x00"),
+])
+def test_collection_encoding_has_complete_readable_buffer(codec, value, expected):
+    encoded = codec.encode(value)
+
+    assert encoded.to_bytes() == expected
+    assert encoded.offset == 0
+    assert encoded.length == len(expected)
+    codec.new().decode(encoded, check_remaining=True)
+    assert encoded.get_remaining_length() == 0
+
+
+def test_vec_does_not_mutate_or_share_preencoded_item_buffer():
+    item = JamBytes(b"\x01\x00")
+    item.get_next_bytes(1)
+    encoded = Vec(U16).encode([item, item])
+
+    assert item.to_bytes() == b"\x01\x00"
+    assert item.offset == 1
+    assert encoded.to_bytes() == b"\x02\x01\x00\x01\x00"
+    item.data[0] = 9
+    assert encoded.to_bytes() == b"\x02\x01\x00\x01\x00"
+    encoded.data[1] = 7
+    assert item.to_bytes() == b"\x09\x00"

{jamcodec-0.1.5 → jamcodec-0.1.7}/test/test_mixins.py

@@ -7,8 +7,9 @@ from os import path
 from typing import Optional, Type, Union, List
 
 from jamcodec.base import JamBytes, JamCodecType
+from jamcodec.exceptions import ScaleDeserializeException, ScaleEncodeException
 from jamcodec.mixins import Serializable, T
-from jamcodec.types import H256, U8, Array, Enum, Option, Null, Bytes
+from jamcodec.types import H256, U8, U16, Array, Enum, Option, Null, Bytes, Map, Struct, StructObject, Vec
 
 
 # Test definitions
@@ -151,6 +152,91 @@ class TestSerializableMixin(unittest.TestCase):
 
         self.assertEqual(self.test_obj, validator_obj)
 
+    def test_binary_enum_encodings(self):
+        cases = (
+            (CustomErrorCode.bad_slot, b'\x00'),
+            (CustomErrorCode.duplicate_ticket, b'\x06'),
+            (Output(ok=OutputMarks(epoch_mark=None)), b'\x00\x00'),
+            (Output(err=CustomErrorCode.duplicate_ticket), b'\x01\x06'),
+            (WorkExecResult(ok=b''), b'\x00\x00'),
+            (WorkExecResult(ok=b'abc'), b'\x00\x03abc'),
+            (WorkExecResult(out_of_gas=Null), b'\x01'),
+        )
+        for value, expected in cases:
+            with self.subTest(value=value):
+                serialized = value.serialize()
+                encoded = value.to_jam_bytes()
+                self.assertEqual(expected, encoded.to_bytes())
+                self.assertEqual(0, encoded.offset)
+                self.assertEqual(serialized, value.serialize())
+
+    def test_binary_nested_collections_roundtrip(self):
+        @dataclass
+        class Packet(Serializable):
+            payload: bytes = field(metadata={'codec': Bytes})
+            numbers: list = field(metadata={'codec': Vec(Option(U16))})
+            labels: dict = field(metadata={'codec': Map(U8, Bytes)})
+
+        packet = Packet(b'abc', [None, 258], {2: b'b', 1: b'a'})
+        encoded = packet.to_jam_bytes()
+        self.assertEqual(b'\x03abc\x02\x00\x01\x02\x01\x02\x01\x01a\x02\x01b', encoded.to_bytes())
+        self.assertEqual(packet, Packet.from_jam_bytes(encoded))
+        self.assertEqual(encoded.length, encoded.offset)
+
+    def test_binary_encoding_returns_independent_buffers(self):
+        value = Output(ok=OutputMarks(epoch_mark=None))
+        first = value.to_jam_bytes()
+        first.get_next_bytes(1)
+        second = value.to_jam_bytes()
+
+        self.assertEqual(1, first.offset)
+        self.assertEqual(0, second.offset)
+        second.data[0] = 99
+        self.assertEqual(b'\x00\x00', first.to_bytes())
+        self.assertEqual(b'\x00\x00', value.to_jam_bytes().to_bytes())
+
+        value.ok.epoch_mark = EpochMark(bytes(32), [bytes(32)] * 6)
+        self.assertEqual(b'\x00\x01' + bytes(32 * 7), value.to_jam_bytes().to_bytes())
+        self.assertEqual(b'\x00\x00', first.to_bytes())
+
+    def test_binary_encoding_preserves_validation(self):
+        @dataclass
+        class Packet(Serializable):
+            number: int = field(metadata={'codec': U8})
+            digest: bytes = field(metadata={'codec': H256})
+
+        for value in (Packet(256, bytes(32)), Packet(1, b'short')):
+            with self.subTest(value=value):
+                with self.assertRaises(ScaleEncodeException):
+                    value.to_jam_bytes()
+
+    def test_binary_encoding_preserves_custom_encoder(self):
+        class PrefixedCodec(StructObject):
+            def encode(self, value=None):
+                return JamBytes(b'\xaa' + super().encode(value).to_bytes())
+
+        @dataclass
+        class Packet(Serializable):
+            number: int
+            _codec_type_def = Struct(number=U8).impl(PrefixedCodec)
+
+        self.assertEqual(b'\xaa\x07', Packet(7).to_jam_bytes().to_bytes())
+
+    def test_binary_encoding_preserves_custom_validation_hook(self):
+        class ValidatedCodec(StructObject):
+            def deserialize(self, value):
+                if self._data is not None:
+                    raise ScaleDeserializeException('custom post-encode validation')
+                return super().deserialize(value)
+
+        @dataclass
+        class Packet(Serializable):
+            number: int
+            _codec_type_def = Struct(number=U8).impl(ValidatedCodec)
+
+        with self.assertRaisesRegex(ScaleDeserializeException, 'custom post-encode validation'):
+            Packet(7).to_jam_bytes()
+
 
 if __name__ == '__main__':
     unittest.main()