structo 0.0.5__tar.gz → 0.0.7__tar.gz

{structo-0.0.5 → structo-0.0.7}/PKG-INFO

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

{structo-0.0.5 → structo-0.0.7}/structo/__init__.py

@@ -2,9 +2,9 @@
 Structify
 """
 
-__version__ = "0.0.5"
+__version__ = "0.0.7"
 
-from .serializer import Serializer, Serialiable
+from .serializer import Serializer, Serializable
 from .serialise import get_serializer
 from .object import SerializableObject
 from .packed import PackedInts, PackedInt

{structo-0.0.5 → structo-0.0.7}/structo/object.py

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

{structo-0.0.5 → structo-0.0.7}/structo/packed.py

@@ -1,4 +1,4 @@
-from .serializer import Serialiable, Serializer
+from .serializer import Serializable, Serializer
 import typing as t
 import io
 from typing import Annotated
@@ -38,7 +38,7 @@ class PackedIntsMeta(type):
 
 # This is very messed up since we
 @t.dataclass_transform()
-class PackedInts(Serialiable, metaclass=PackedIntsMeta):
+class PackedInts(Serializable, metaclass=PackedIntsMeta):
     _bits: dict[str, PackedInt]
 
     @classmethod

{structo-0.0.5 → structo-0.0.7}/structo/serialise.py

@@ -1,8 +1,18 @@
 import typing as t
-from .serializer import Serializer, Serialiable
+from .serializer import Serializer, Serializable
 
 
-def get_serializer(format: type) -> Serializer:
+def to_serializer[T](format: type[T] | Serializer[T]) -> Serializer[T]:
+    if isinstance(format, Serializer):
+        return format
+
+    if isinstance(format, type) and issubclass(format, Serializable):
+        return format.serializer()
+
+    raise AssertionError(f"Invalid value_type: {format}")
+
+
+def get_serializer(format: type | Serializer) -> Serializer:
     if t.get_origin(format) is t.Annotated:
         args = t.get_args(format)
         serializers = [arg for arg in args if isinstance(arg, Serializer)]
@@ -12,7 +22,7 @@ def get_serializer(format: type) -> Serializer:
 
         return serializer
 
-    if isinstance(format, Serialiable):
+    if issubclass(format, Serializable):
         return format.serializer()
 
     # Nicely formatted errors:

{structo-0.0.5 → structo-0.0.7}/structo/serializer.py

@@ -2,7 +2,7 @@ import io
 import typing as t
 
 
-class Serialiable:
+class Serializable:
     @classmethod
     def serializer(cls) -> Serializer[t.Self]: ...
 

{structo-0.0.5 → structo-0.0.7}/structo/types/array.py

@@ -1,14 +1,15 @@
+from ..serialise import to_serializer
 from ..serializer import Serializer
 
 
 class Array[T](Serializer[list[T]]):
     length: int
-    type: Serializer[T]
+    value_type: Serializer[T]
 
-    def __init__(self, length: int, type: Serializer[T]) -> None:
+    def __init__(self, length: int, value_type: Serializer[T] | type[T]) -> None:
         assert length > 0, "Array must be longer than 0"
         self.length = length
-        self.type = type
+        self.value_type = to_serializer(value_type)
 
     def write(self, buf, value):
         assert (
@@ -16,19 +17,18 @@ class Array[T](Serializer[list[T]]):
         ), f"expected array with {self.length} length, receieved {len(value)}"
 
         for item in value:
-            self.type.write(buf, item)
+            self.value_type.write(buf, item)
 
     def read(self, buf):
         items = []
         for _ in range(self.length):
-            items.append(self.type.read(buf))
+            items.append(self.value_type.read(buf))
 
         return items
 
     def sizeof(self):
-        element_length = self.type.sizeof()
+        element_length = self.value_type.sizeof()
         if element_length is None:
             return None
         else:
             return element_length * self.length
-

{structo-0.0.5 → structo-0.0.7}/structo/types/list.py

@@ -1,6 +1,7 @@
 import typing as t
+from ..serialise import to_serializer
 from ..serializer import Serializer
-from ..object import SerializableObject
+from ..object import Serializable
 
 
 class List[T](Serializer[list[T]]):
@@ -9,22 +10,11 @@ class List[T](Serializer[list[T]]):
     length_type: Serializer[int]
     value_type: Serializer
 
-    @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: Serializer[int], value_type: Serializer[T] | type[T]
+    ) -> None:
         self.length_type = length_type
-        if isinstance(value_type, SerializableObject):
-            self.value_type = value_type.serializer()
-        else:
-            self.value_type = value_type
+        self.value_type = to_serializer(value_type)
 
     def write(self, buf, value):
         length = len(value)

structo-0.0.7/tests/test_array.py

@@ -0,0 +1,20 @@
+import typing as t
+import structo as st
+from utils import test
+
+
+@test("Array: sizeof")
+def _():
+    assert st.Array(4, st.int8).sizeof() == 4
+
+
+@test("Array: nested bits")
+def _():
+    class Bits(st.PackedInts):
+        a: t.Annotated[int, st.PackedInt(bits=2)]
+
+    class Object(st.SerializableObject):
+        bits: t.Annotated[list[Bits], st.Array(2, Bits)]
+
+    obj = Object(bits=[Bits(1), Bits(2)])
+    assert obj == Object.from_bytes(obj.to_bytes())

structo-0.0.7/tests/test_list.py

@@ -0,0 +1,17 @@
+from utils import test
+import typing as t
+
+import structo as st
+
+
+@test("List: nested bits")
+def _():
+    class Bits(st.PackedInts):
+        a: t.Annotated[int, st.PackedInt(bits=2)]
+
+    class Object(st.SerializableObject):
+        foo: t.Annotated[list[Bits], st.List(st.uint8, Bits)]
+
+    obj = Object(foo=[Bits(a=1)])
+    assert obj == Object.from_bytes(obj.to_bytes())
+

structo-0.0.7/tests/test_object.py

@@ -0,0 +1,55 @@
+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.5/tests/test_array.py

@@ -1,7 +0,0 @@
-import structo as st
-from utils import test
-
-
-@test("Array: sizeof")
-def _():
-    assert st.Array(4, st.int8).sizeof() == 4