structo 0.0.4__tar.gz → 0.0.6__tar.gz

{structo-0.0.4 → structo-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structo
-Version: 0.0.4
+Version: 0.0.6
 Summary: Structify
 Author-email: Ben Brady <benbradybusiness@gmail.com>
 License-Expression: MIT

{structo-0.0.4 → structo-0.0.6}/structo/__init__.py

@@ -2,9 +2,12 @@
 Structify
 """
 
-__version__ = "0.0.4"
+__version__ = "0.0.6"
 
-from .serializer import Serializer
+from .serializer import Serializer, Serialiable
+from .serialise import get_serializer
+from .object import SerializableObject
+from .packed import PackedInts, PackedInt
 from .types import (
     uint64_BE,
     uint64_LE,
@@ -40,7 +43,6 @@ from .types import (
     Literal,
     ObjectSerializer,
 )
-from .object import SerializableObject
 from .utils import (
     StructoReader,
     StructifyWriter,

{structo-0.0.4 → structo-0.0.6}/structo/object.py

@@ -3,7 +3,7 @@ import annotationlib
 import typing as t
 from dataclasses import dataclass
 
-from .serializer import Serializer
+from .serializer import Serialiable, Serializer
 from .serialise import get_serializer
 
 
@@ -32,11 +32,10 @@ class SerializableObjectMeta(type):
 
 # This is very messed up since we
 @t.dataclass_transform()
-class SerializableObject(metaclass=SerializableObjectMeta):
+class SerializableObject(Serialiable, metaclass=SerializableObjectMeta):
     @classmethod
     def serializer(cls) -> Serializer[t.Self]:
         from .types import ObjectSerializer
-
         return ObjectSerializer(cls)
 
     @classmethod

structo-0.0.6/structo/packed.py

@@ -0,0 +1,78 @@
+from .serializer import Serialiable, Serializer
+import typing as t
+import io
+from typing import Annotated
+from dataclasses import dataclass
+import annotationlib
+
+
+class PackedInt:
+    bits: int
+
+    def __init__(self, *, bits: int) -> None:
+        self.bits = bits
+
+
+class PackedIntsMeta(type):
+    def __new__(cls, name, bases, dct):
+        new_class = t.cast(type, super().__new__(cls, name, bases, dct))
+        if name == "PackedInts":
+            return new_class
+
+        annotate = annotationlib.get_annotate_from_class_namespace(dct)
+        assert annotate
+
+        bits: dict[str, PackedInt] = {}
+        attrs = annotate(annotationlib.Format.VALUE_WITH_FAKE_GLOBALS)
+        for key, value in attrs.items():
+            assert t.get_origin(value) is t.Annotated
+
+            ints = [arg for arg in t.get_args(value) if isinstance(arg, PackedInt)]
+            assert len(ints) == 1
+            bits[key] = ints[0]
+
+        obj = t.cast(PackedInts, dataclass(new_class))
+        obj._bits = bits
+        return obj
+
+
+# This is very messed up since we
+@t.dataclass_transform()
+class PackedInts(Serialiable, metaclass=PackedIntsMeta):
+    _bits: dict[str, PackedInt]
+
+    @classmethod
+    def serializer(cls) -> Serializer[t.Self]:
+        from .types import PackedIntSerializer
+
+        return PackedIntSerializer(cls)
+
+    @classmethod
+    def sizeof(cls) -> int | None:
+        return cls.serializer().sizeof()
+
+    def write(self, buf: io.Writer):
+        return self.serializer().write(buf, self)
+
+    @classmethod
+    def read(cls, buf: io.Reader) -> t.Self:
+        return cls.serializer().read(buf)
+
+    def to_bytes(self) -> bytes:
+        return self.serializer().to_bytes(self)
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> t.Self:
+        return cls.serializer().from_bytes(data)
+
+
+class Foo(PackedInts):
+    type: Annotated[int, PackedInt(bits=2)]
+    bar: Annotated[int, PackedInt(bits=10)]
+    offset: Annotated[int, PackedInt(bits=4)]
+
+
+obj = Foo(type=1, bar=2, offset=3)
+
+print(obj)
+print(Foo.from_bytes(obj.to_bytes()))

{structo-0.0.4 → structo-0.0.6}/structo/serialise.py

@@ -1,13 +1,8 @@
-import io
 import typing as t
-from .serializer import Serializer
+from .serializer import Serializer, Serialiable
 
 
 def get_serializer(format: type) -> Serializer:
-    from .serializer import Serializer
-    from .object import SerializableObject
-    from .types.object import ObjectSerializer
-
     if t.get_origin(format) is t.Annotated:
         args = t.get_args(format)
         serializers = [arg for arg in args if isinstance(arg, Serializer)]
@@ -17,8 +12,8 @@ def get_serializer(format: type) -> Serializer:
 
         return serializer
 
-    if issubclass(format, SerializableObject):
-        return ObjectSerializer(format)
+    if issubclass(format, Serialiable):
+        return format.serializer()
 
     # Nicely formatted errors:
     if format == int:

{structo-0.0.4 → structo-0.0.6}/structo/serializer.py

@@ -1,4 +1,10 @@
 import io
+import typing as t
+
+
+class Serialiable:
+    @classmethod
+    def serializer(cls) -> Serializer[t.Self]: ...
 
 
 class Serializer[T]:

{structo-0.0.4 → structo-0.0.6}/structo/types/__init__.py

@@ -33,3 +33,4 @@ from .list import List
 from .string import String
 from .literal import Literal
 from .object import ObjectSerializer
+from .packed import PackedIntSerializer

{structo-0.0.4 → structo-0.0.6}/structo/types/list.py

@@ -1,15 +1,30 @@
+import typing as t
 from ..serializer import Serializer
+from ..object import SerializableObject
 
 
 class List[T](Serializer[list[T]]):
     "A list of items, prefixed with it's length"
 
-    value_type: Serializer[T]
     length_type: Serializer[int]
+    value_type: Serializer
 
-    def __init__(self, length_type: Serializer[int], value_type: Serializer[T]) -> None:
+    @t.overload
+    def __init__(
+        self, length_type: Serializer[int], value_type: Serializer[T]
+    ) -> None: ...
+
+    @t.overload
+    def __init__(
+        self, length_type: Serializer[int], value_type: T
+    ) -> None: ...
+
+    def __init__(self, length_type: Serializer[int], value_type: Serializer | SerializableObject) -> None:
         self.length_type = length_type
-        self.value_type = value_type
+        if isinstance(value_type, SerializableObject):
+            self.value_type = value_type.serializer()
+        else:
+            self.value_type = value_type
 
     def write(self, buf, value):
         length = len(value)

structo-0.0.6/structo/types/packed.py

@@ -0,0 +1,59 @@
+from io import Reader, Writer
+from math import ceil
+
+from structo import Serializer
+from ..packed import PackedInts, PackedInt
+import typing as t
+
+
+class PackedIntSerializer[T: PackedInts](Serializer[T]):
+    size: int
+    _bits: dict[str, int]
+    _cls: type[type[T]]
+
+    def __init__(self, cls: type[T]) -> None:
+        total_bits = sum(x.bits for x in cls._bits.values())
+        self._cls = cls
+        self.size = ceil(total_bits / 8)
+
+        self._bits = {}
+        for key, value in cls._bits.items():
+            self._bits[key] = value.bits
+
+    def write(self, buf: Writer, value: T):
+        output = 0
+        offset = 0
+        for field_key, bits in self._bits.items():
+            field_value = getattr(value, field_key)
+
+            max_value = (2**bits) - 1
+            assert field_value <= max_value, f"{self._cls.__name__}{field_key} exceed max value, {field_value} > {max_value}"
+            output += field_value << offset
+            offset += bits
+
+        data = bytearray(self.size)
+        for x in range(self.size):
+            byte = output & 255
+            output >>= 8
+            data[x] = byte
+
+        buf.write(data)
+
+    def read(self, buf: Reader) -> T:
+        data = buf.read(self.size)
+        integer = int.from_bytes(data, "little")
+        attrs: dict[str, t.Any] = {}
+
+        offset = 0
+        for field_key, bits in self._bits.items():
+
+            mask = (2**bits) - 1
+            value = (integer >> offset) & mask
+
+            offset += bits
+            attrs[field_key] = value
+
+        return self._cls(**attrs)
+
+    def sizeof(self) -> int:
+        return self.size

structo-0.0.6/tests/test_object.py

@@ -0,0 +1,54 @@
+from utils import test
+import typing as t
+
+import structo as st
+
+
+@test("SerialiableObject: object")
+def _():
+    class Foo(st.SerializableObject):
+        a: t.Annotated[int, st.uint8]
+
+    obj = Foo(a=1)
+    assert obj == Foo.from_bytes(obj.to_bytes())
+
+
+@test("SerialiableObject: multiple attributes")
+def _():
+    class Foo(st.SerializableObject):
+        a: t.Annotated[int, st.uint8]
+        b: t.Annotated[int, st.uint16_BE]
+
+    obj = Foo(a=1, b=256)
+    assert obj == Foo.from_bytes(obj.to_bytes())
+
+
+@test("SerialiableObject: sizeof")
+def _():
+
+    class Foo(st.SerializableObject):
+        a: t.Annotated[int, st.uint8]
+        b: t.Annotated[str, st.uint8]
+
+    assert Foo.sizeof() == 2
+
+
+@test("SerialiableObject: sizeof unknowable")
+def _():
+    class Foo(st.SerializableObject):
+        a: t.Annotated[int, st.uint8]
+        b: t.Annotated[str, st.String(st.uint8)]
+
+    assert Foo.sizeof() is None
+
+
+@test("SerialiableObject: nested object")
+def _():
+    class Foo(st.SerializableObject):
+        a: t.Annotated[int, st.uint8]
+
+    class Bar(st.SerializableObject):
+        foo: Foo
+
+    obj = Bar(foo=Foo(1))
+    assert obj == Bar.from_bytes(obj.to_bytes())

structo-0.0.6/tests/test_packed.py

@@ -0,0 +1,95 @@
+from utils import test
+import typing as t
+
+import pytest
+import structo as st
+
+
+@test("PackedInts: serialise on single bytes")
+def _():
+    class Foo(st.PackedInts):
+        a: t.Annotated[int, st.PackedInt(bits=2)]
+        b: t.Annotated[int, st.PackedInt(bits=3)]
+
+    obj = Foo(a=0, b=3)
+    assert obj == Foo.from_bytes(obj.to_bytes())
+
+
+@test("PackedInts: serialise across byte boundaries single bytes")
+def _():
+    class Foo(st.PackedInts):
+        a: t.Annotated[int, st.PackedInt(bits=5)]
+        b: t.Annotated[int, st.PackedInt(bits=6)]
+        c: t.Annotated[int, st.PackedInt(bits=5)]
+
+    obj = Foo(a=0, b=63, c=0)
+    assert obj == Foo.from_bytes(obj.to_bytes())
+
+@test("PackedInts: multibyte integer")
+def _():
+    class Foo(st.PackedInts):
+        a: t.Annotated[int, st.PackedInt(bits=11)]
+        b: t.Annotated[int, st.PackedInt(bits=5)]
+
+    obj = Foo(a=(2 ** 11) - 1, b=0)
+    assert obj == Foo.from_bytes(obj.to_bytes())
+
+
+@test("PackedInts: max value throw error")
+def _():
+    class Foo(st.PackedInts):
+        a: t.Annotated[int, st.PackedInt(bits=2)]
+
+    with pytest.raises(Exception):
+        Foo(a=4).to_bytes()
+
+
+@test("PackedInts: max value throw error on constructor")
+@pytest.mark.skip()
+def _():
+    class Foo(st.PackedInts):
+        a: t.Annotated[int, st.PackedInt(bits=2)]
+
+    with pytest.raises(Exception):
+        Foo(a=4)
+
+
+@test("PackedInts: sizeof")
+def _():
+    class OneByte_A(st.PackedInts):
+        a: t.Annotated[int, st.PackedInt(bits=2)]
+        b: t.Annotated[int, st.PackedInt(bits=1)]
+
+    assert OneByte_A.sizeof() == 1
+
+    class OneByte_B(st.PackedInts):
+        a: t.Annotated[int, st.PackedInt(bits=8)]
+
+    assert OneByte_B.sizeof() == 1
+
+    class OneByte_C(st.PackedInts):
+        a: t.Annotated[int, st.PackedInt(bits=3)]
+        b: t.Annotated[int, st.PackedInt(bits=3)]
+        c: t.Annotated[int, st.PackedInt(bits=2)]
+
+    assert OneByte_C.sizeof() == 1
+
+    class TwoBytes_A(st.PackedInts):
+        a: t.Annotated[int, st.PackedInt(bits=5)]
+        b: t.Annotated[int, st.PackedInt(bits=4)]
+
+    assert TwoBytes_A.sizeof() == 2
+
+    class TwoBytes_B(st.PackedInts):
+        a: t.Annotated[int, st.PackedInt(bits=6)]
+        b: t.Annotated[int, st.PackedInt(bits=6)]
+        c: t.Annotated[int, st.PackedInt(bits=4)]
+
+    assert TwoBytes_B.sizeof() == 2
+
+    class ThreeBytes_A(st.PackedInts):
+        a: t.Annotated[int, st.PackedInt(bits=6)]
+        b: t.Annotated[int, st.PackedInt(bits=6)]
+        c: t.Annotated[int, st.PackedInt(bits=5)]
+
+    assert ThreeBytes_A.sizeof() == 3

structo-0.0.4/union.py

@@ -1,8 +0,0 @@
-from structo import Literal, serialize_to_bytes, SerializableObject
-
-
-class Foo(SerializableObject):
-    bar: Literal[b"foo"] = ... # type: ignore
-
-
-serialize_to_bytes(Literal[b"foo"], b"foo")