structo 0.0.1__tar.gz

structo-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Ben Brady
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

structo-0.0.1/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: structo
+Version: 0.0.1
+Summary: Structify
+Author-email: Ben Brady <benbradybusiness@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Project-URL: Home, https://nnilky.site

structo-0.0.1/pyproject.toml

@@ -0,0 +1,13 @@
+[build-system]
+requires = ["flit_core >=3.11,<4"]
+build-backend = "flit_core.buildapi"
+
+[project]
+name = "structo"
+authors = [{name = "Ben Brady", email = "benbradybusiness@gmail.com"}]
+license = "MIT"
+license-files = ["LICENSE"]
+dynamic = ["version", "description"]
+
+[project.urls]
+Home = "https://nnilky.site"

structo-0.0.1/structo/__init__.py

@@ -0,0 +1,28 @@
+"""
+Structify
+"""
+
+__version__ = "0.0.1"
+
+from .serialise import serialize, deserialize
+from .types import (
+    SerialiableObject,
+    uint8,
+    uint16,
+    uint32,
+    uint64,
+    int8,
+    int16,
+    int32,
+    int64,
+    float32,
+    float64,
+    array,
+    string,
+)
+from .utils import (
+    StructifyReader,
+    StructifyWriter,
+    serialize_to_bytes,
+    deserialize_from_bytes,
+)

structo-0.0.1/structo/serialise.py

@@ -0,0 +1,169 @@
+import annotationlib
+import io
+import struct
+import typing as t
+
+from .types import (
+    Format,
+    SerialiableObject,
+    array,
+    string,
+    blob,
+    uint64,
+    uint32,
+    uint16,
+    uint8,
+    int64,
+    int32,
+    int16,
+    int8,
+    float64,
+    float32,
+)
+
+
+class Serializer[T]:
+    @staticmethod
+    def write(buf: io.Writer, format: Format, value: T): ...
+
+    @staticmethod
+    def read(buf: io.Reader, format: Format) -> T: ...
+
+
+class SerialiableObjectSerializer(Serializer):
+    @staticmethod
+    def write(buf: io.Writer, format: type, value: SerialiableObject):
+        annotations = annotationlib.get_annotations(format)
+        for field_key, field_format in annotations.items():
+            field_value = getattr(value, field_key)
+            serialize(buf, field_format, field_value)
+
+    @staticmethod
+    def read(buf: io.Reader, format: type) -> SerialiableObject:
+        annotations = annotationlib.get_annotations(format)
+        attrs = {}
+        for field_key, field_format in annotations.items():
+            field_value = deserialize(buf, field_format)
+            attrs[field_key] = field_value
+
+        return format(**attrs)
+
+
+class ArraySerializer(Serializer[list]):
+    @staticmethod
+    def write(buf: io.Writer, format: Format, value: list):
+        tlength, tvalue = t.get_args(format)
+
+        length = len(value)
+        serialize(buf, tlength, length)
+        for item in value:
+            serialize(buf, tvalue, item)
+
+    @staticmethod
+    def read(buf: io.Reader, format: Format):
+        tlength, tvalue = t.get_args(format)
+
+        length = read_uint(buf, tlength)
+        values = []
+        for _ in range(length):
+            value = deserialize(buf, tvalue)
+            values.append(value)
+
+        return values
+
+
+class StringSerializer(Serializer[str]):
+    @staticmethod
+    def write(buf: io.Writer, format: Format, value: str):
+        (tlength,) = t.get_args(format)
+
+        data = value.encode("utf-8")
+        length = len(data)
+
+        serialize(buf, tlength, length)
+        buf.write(data)
+
+    @staticmethod
+    def read(buf: io.Reader, format: Format):
+        (tlength,) = t.get_args(format)
+
+        length = deserialize(buf, tlength)
+        data = buf.read(length)
+        return data.decode("utf-8")
+
+
+class BlobSerializer(Serializer[bytes]):
+    @staticmethod
+    def write(buf: io.Writer, format: Format, value: bytes):
+        (tlength,) = t.get_args(format)
+
+        length = len(value)
+        serialize(buf, tlength, length)
+        buf.write(value)
+
+    @staticmethod
+    def read(buf: io.Reader, format: Format):
+        (tlength,) = t.get_args(format)
+
+        length = deserialize(buf, tlength)
+        data = buf.read(length)
+        return data
+
+
+def create_struct_serializer[T](sformat: str, length: int) -> type[Serializer[T]]:
+    class StructSerializer(Serializer[T]):
+        @staticmethod
+        def write(buf: io.Writer, _: type, value: int):
+            return buf.write(struct.pack(sformat, value))
+
+        @staticmethod
+        def read(buf: io.Reader, _: type):
+            return struct.unpack(sformat, buf.read(length))[0]
+
+    return StructSerializer
+
+
+def _get_serializer(format: Format) -> type[Serializer]:
+    DIRECT_PRIMATIVES = {
+        uint64: create_struct_serializer(">Q", 8),
+        uint32: create_struct_serializer(">I", 4),
+        uint16: create_struct_serializer(">H", 2),
+        uint8: create_struct_serializer("B", 1),
+        int64: create_struct_serializer(">q", 8),
+        int32: create_struct_serializer(">i", 4),
+        int16: create_struct_serializer(">h", 2),
+        int8: create_struct_serializer("b", 1),
+        float64: create_struct_serializer(">d", 8),
+        float32: create_struct_serializer(">f", 4),
+    }
+
+    if format in DIRECT_PRIMATIVES:
+        return DIRECT_PRIMATIVES[format]
+
+    GENERICS_PRIMATIVES = {
+        array: ArraySerializer,
+        string: StringSerializer,
+        blob: BlobSerializer,
+    }
+    origin = t.get_origin(format)
+    if origin in GENERICS_PRIMATIVES:
+        return GENERICS_PRIMATIVES[origin]
+
+    if isinstance(format, type) and issubclass(format, SerialiableObject):
+        return SerialiableObjectSerializer
+
+    raise NotImplementedError(f"No serializer for {format}")
+
+
+def read_uint(buf: io.Reader, format: Format) -> int:
+    value = deserialize(buf, format)
+    assert isinstance(value, int), "uint not value"
+    return value
+
+
+def serialize(buf: io.Writer, format: Format, value: t.Any):
+    return _get_serializer(format).write(buf, format, value)
+
+
+def deserialize(buf: io.Reader, format: Format) -> t.Any:
+    return _get_serializer(format).read(buf, format)

structo-0.0.1/structo/types.py

@@ -0,0 +1,80 @@
+import typing as t
+import io
+from dataclasses import dataclass
+import annotationlib
+import struct
+
+
+type uint8 = int
+type uint16 = int
+type uint32 = int
+type uint64 = int
+
+type int8 = int
+type int16 = int
+type int32 = int
+type int64 = int
+
+type float32 = float
+type float64 = float
+
+type uint = uint8 | uint16 | uint32 | uint64
+type sint = int8 | int16 | int32 | int64
+
+
+type blob[Length: uint] = bytes
+"""
+blob[Length: uint]
+
+> Length: The integer type used to store the length
+"""
+type string[Length: uint] = str
+"""
+string[Length: uint]
+
+> Length: The integer type used to store the length
+"""
+
+type array[Length: uint, Value: Serializable] = list
+"""
+array[Length: uint, Value: Serializable]
+
+> Length: The integer type used to store the length
+
+> Value: The value to store in the array
+"""
+
+
+class _SerialiableObjectMeta(type):
+    def __new__(cls, name, bases, dct):
+        new_class = super().__new__(cls, name, bases, dct)
+        return dataclass(new_class)  # type: ignore
+
+
+@t.dataclass_transform()
+class SerialiableObject(metaclass=_SerialiableObjectMeta):
+    @classmethod
+    def read(cls, buf: io.Reader) -> t.Self:
+        from .serialise import deserialize
+
+        return deserialize(buf, type(cls))
+
+    def write(self, buf: io.Writer):
+        from .serialise import serialize
+
+        serialize(buf, type(self), self)
+
+    def from_bytes(self, data: bytes) -> t.Self:
+        buf = io.BytesIO(data)
+        return self.read(buf)
+
+    def to_bytes(self) -> bytes:
+        buf = io.BytesIO()
+        self.write(buf)
+        buf.seek(0)
+        return buf.read()
+
+
+type Primative = string | array | uint | int | float
+type Serializable = SerialiableObject | Primative
+type Format = type | t.TypeAliasType

structo-0.0.1/structo/utils.py

@@ -0,0 +1,128 @@
+import typing as t
+import io
+from .types import (
+    Format,
+    SerialiableObject,
+    uint8,
+    uint16,
+    uint32,
+    uint64,
+    int8,
+    int16,
+    int32,
+    int64,
+    float32,
+    float64,
+    blob,
+    string,
+)
+from .serialise import serialize, deserialize
+
+
+def serialize_to_bytes(format: Format, value: t.Any) -> bytes:
+    buf = io.BytesIO()
+    serialize(buf, format, value)
+    buf.seek(0)
+    return buf.read()
+
+
+def deserialize_from_bytes(format: Format, data: bytes) -> t.Any:
+    buf = io.BytesIO(data)
+    return deserialize(buf, format)
+
+
+class StructifyReader:
+    reader: io.Reader
+
+    def __init__(self, reader: io.Reader) -> None:
+        self.reader = reader
+
+    @t.overload
+    def read[T: SerialiableObject](self, format: type[T]) -> T: ...
+
+    @t.overload
+    def read(self, format: Format) -> t.Any: ...
+
+    def read(self, format: Format) -> t.Any:
+        return deserialize(self.reader, format)
+
+    def read_uint8(self) -> int:
+        return self.read(uint8)
+
+    def read_uint16(self) -> int:
+        return self.read(uint16)
+
+    def read_uint32(self) -> int:
+        return self.read(uint32)
+
+    def read_uint64(self) -> int:
+        return self.read(uint64)
+
+    def read_int8(self) -> int:
+        return self.read(int8)
+
+    def read_int16(self) -> int:
+        return self.read(int16)
+
+    def read_int32(self) -> int:
+        return self.read(int32)
+
+    def read_int64(self) -> int:
+        return self.read(int64)
+
+    def read_float32(self) -> float:
+        return self.read(float32)
+
+    def read_float64(self) -> float:
+        return self.read(float64)
+
+    def read_blob(self) -> bytes:
+        return self.read(blob)
+
+    def read_string(self) -> str:
+        return self.read(string)
+
+class StructifyWriter:
+    buf: io.Writer
+
+    def __init__(self, buf: io.Writer) -> None:
+        self.buf = buf
+
+    def write(self, format: Format, value: t.Any) -> t.Any:
+        return serialize(self.buf, format, value)
+
+    def write_uint8(self, value: int):
+        return self.write(uint8, value)
+
+    def write_uint16(self, value: int):
+        return self.write(uint16, value)
+
+    def write_uint32(self, value: int):
+        return self.write(uint32, value)
+
+    def write_uint64(self, value: int):
+        return self.write(uint64, value)
+
+    def write_int8(self, value: int):
+        return self.write(int8, value)
+
+    def write_int16(self, value: int):
+        return self.write(int16, value)
+
+    def write_int32(self, value: int):
+        return self.write(int32, value)
+
+    def write_int64(self, value: int):
+        return self.write(int64, value)
+
+    def write_float32(self, value: float):
+        return self.write(float32, value)
+
+    def write_float64(self, value: float):
+        return self.write(float64, value)
+
+    def write_blob(self, value: bytes):
+        return self.write(string, value)
+
+    def write_string(self, value: str):
+        return self.write(string, value)