Hydrogenlib-Objective-Struct 0.0.1__tar.gz

hydrogenlib_objective_struct-0.0.1/.gitignore

@@ -0,0 +1,17 @@
+# Dist and build files
+/**/__pycache__/
+/**/dist/
+/**/build/
+/**/.venv/
+
+# IDE settings
+/.idea/
+/.vscode/
+
+# Files in Dev
+/**/.temp/
+/**/.tests/
+/**/tests
+/**/dev-scripts/
+/**/uv.lock
+/**/.hydro-ignore

hydrogenlib_objective_struct-0.0.1/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: Hydrogenlib-Objective-Struct
+Version: 0.0.1
+Project-URL: Documentation, https://github.com/LittleNightSong/HydrogenLib#readme
+Project-URL: Issues, https://github.com/LittleNightSong/HydrogenLib/issues
+Project-URL: Source, https://github.com/LittleNightSong/HydrogenLib
+Author-email: LittleNightSong <LittleNightSongYO@outlook.com>
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.12

hydrogenlib_objective_struct-0.0.1/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "Hydrogenlib-Objective-Struct"
+dynamic = ["version"]
+description = ''
+readme = "README.md"
+requires-python = ">=3.12"
+keywords = []
+classifiers = ["Development Status :: 3 - Alpha", "Programming Language :: Python", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Programming Language :: Python :: 3.13", "Programming Language :: Python :: Implementation :: CPython", "Programming Language :: Python :: Implementation :: PyPy"]
+dependencies = []
+
+[[project.authors]]
+name = "LittleNightSong"
+email = "LittleNightSongYO@outlook.com"
+[project.urls]
+Documentation = "https://github.com/LittleNightSong/HydrogenLib#readme"
+Issues = "https://github.com/LittleNightSong/HydrogenLib/issues"
+Source = "https://github.com/LittleNightSong/HydrogenLib"
+
+[tool.hatch.version]
+path = "src/_hydrogenlib_objective_struct/__about__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/_hydrogenlib_objective_struct"]
+

hydrogenlib_objective_struct-0.0.1/src/_hydrogenlib_objective_struct/__about__.py

@@ -0,0 +1 @@
+version = "0.0.1"

hydrogenlib_objective_struct-0.0.1/src/_hydrogenlib_objective_struct/__init__.py

@@ -0,0 +1,3 @@
+from .methods import pack, unpack
+from .objective_struct import Struct
+from .types import *

hydrogenlib_objective_struct-0.0.1/src/_hydrogenlib_objective_struct/methods.py

@@ -0,0 +1,26 @@
+import struct
+import typing
+from collections.abc import Buffer
+from typing import Any
+
+
+class _CType(typing.Protocol):
+    __ctype__: str
+
+
+def to_format_string(format: tuple[str | _CType, ...]):
+    format = ''.join(
+        map(
+            lambda x: x if isinstance(x, str) else x.__ctype__,
+            format
+        )
+    )
+    return format
+
+
+def pack(format: tuple[str | _CType, ...], *data: Any) -> bytes:
+    return struct.pack(to_format_string(format), *data)
+
+
+def unpack(format: tuple[str | _CType], data: Buffer):
+    return struct.unpack(to_format_string(format), data)

hydrogenlib_objective_struct-0.0.1/src/_hydrogenlib_objective_struct/objective_struct.py

@@ -0,0 +1,223 @@
+import copy
+import inspect
+import struct
+from collections import OrderedDict
+from collections.abc import Buffer
+from typing import Self, Generator
+
+from _hydrogenlib_core.typefunc import AutoSlots
+
+endian_control_characters = tuple('<@=!>')
+
+_AOT_TEMPLATE = """
+def pack(self):
+    return self.__st_struct__.pack({selfattrs})
+
+def pack_into(self, buffer, offset=0):
+    self.__st_struct__.pack_into(buffer, offset, {selfattrs})
+
+@classmethod
+def unpack(cls, buffer):
+    self = object.__new__(cls)
+    {selfattrs} = self.__st_struct__.unpack(buffer)
+    return self
+
+@classmethod
+def unpack_from(cls, buffer, offset=0):
+    self = object.__new__(cls)
+    {selfattrs} = cls.__st_struct__.unpack_from(buffer, offset)
+    return self
+
+@classmethod
+def iter_unpack(cls, buffer):
+    for values in cls.__st_struct__.iter_unpack(buffer):
+        self = object.__new__(cls)
+        {selfattrs} = values
+        yield self
+
+@classmethod
+def iter_unpack_reused(cls, buffer):
+    self = object.__new__(cls)
+    for values in cls.__st_struct__.iter_unpack(buffer):
+        {selfattrs} = values
+        yield self
+
+def update_from(self, buffer, offset=0):
+    {selfattrs} = self.__st_struct__.unpack_from(buffer, offset)
+    return self
+    
+def __init__(self, {init_signature}):
+    {selfattrs} = {attrs}
+    
+"""
+
+
+class Struct(AutoSlots):
+    """
+    Base class for creating structured data with a defined format, suitable for packing and unpacking binary data.
+
+    This class allows the creation of a structure that can be used to pack and unpack binary data according to a
+    specified format. It supports type annotations for defining the fields of the structure.
+    The class automatically generates the necessary format string for the `struct` module based on the provided
+    field types. It also provides methods for comparing instances, packing and unpacking data,
+    and converting the structure to a dictionary representation.
+
+    Usage:
+        class MyStruct(Struct):
+            a: int
+            b: bool
+            c: float
+    """
+    __no_slots__ = (
+        '__st_fields__', '__st_struct__', '__st_format__', '__st_order__',
+        '__ost_fields__'
+    )
+
+    __st_fields__: dict[str, type] = None
+    __st_struct__: struct.Struct = None
+    __st_format__: str = ''
+    __st_order__: str = '@'
+
+    # optimize attributes
+    __ost_fields__: tuple[str, ...] = None
+
+    # __ost_methods__: dict[str, Callable] = None
+
+    def __init_subclass__(cls, *, middle=False, endian: str = '@', **kwargs):
+        if middle:
+            return
+
+        from .types import get_ctype
+
+        cls.__st_fields__ = copy.copy(cls.__st_fields__) or OrderedDict()  # 继承父类型的字段
+
+        new_fields = OrderedDict()
+        for name, anno in inspect.get_annotations(cls).items():
+            if name in cls.__st_fields__:
+                raise TypeError(f"Field {name!r} is already defined")
+            new_fields[name] = get_ctype(anno)
+
+        cls.__st_fields__.update(new_fields)
+        cls.__st_format__ += ''.join(new_fields.values())  # 更新新字段的 format string
+
+        if cls.__st_format__.startswith(endian_control_characters):  # 修改字节序
+            if cls.__st_format__[0] != endian:
+                cls.__st_format__ = endian + cls.__st_format__[1:]
+
+        cls.__st_struct__ = struct.Struct(cls.__st_format__)  # 构造 Struct 类型
+
+        # 优化
+        # 生成 ost-fields
+        # cls.__ost_fields__ = tuple(cls.__st_fields__.keys())
+
+        cls.__ost_fields__ = field_names = tuple(cls.__st_fields__.keys())
+
+        selfattrs = ', '.join(
+            map(
+                lambda x: f'self.{x}',
+                field_names
+            )
+        )
+
+        def _processor(name):
+            if name in cls.__migrated__:
+                return f'{name}={cls.__migrated__[name]}'
+            else:
+                return f'{name}'
+
+        # 生成 init 方法的签名
+        init_signature = ', '.join(
+            map(
+                _processor,
+                field_names
+            )
+        )
+
+        # 普通的字段元组
+        simple_attrs = ', '.join(field_names)
+
+        # 生成 ost-methods
+        gl = {}
+        exec(
+            _AOT_TEMPLATE.format(
+                selfattrs=selfattrs,
+                init_signature=init_signature,
+                attrs=simple_attrs,
+            ),
+            globals=gl
+        )
+
+        cls.__ost_methods__ = gl
+
+        cls.pack = gl['pack']
+        cls.pack_into = gl['pack_into']
+        cls.unpack = gl['unpack']
+        cls.unpack_from = gl['unpack_from']
+        cls.iter_unpack = gl['iter_unpack']
+        cls.iter_unpack_reused = gl['iter_unpack_reused']
+        cls.update_from = gl['update_from']
+        cls.__init__ = gl['__init__']
+
+    def __init__(self, *args, **kwargs) -> None:
+        ...
+
+    def __eq__(self, other):
+        if isinstance(other, Struct):
+            return other.__st_format__ == other.__st_format__ and self.to_dict() == other.to_dict()
+        elif isinstance(other, dict):
+            return self.to_dict() == other
+        elif isinstance(other, bytes):
+            return self.unpack(other) == self
+        else:
+            raise NotImplementedError(other)
+
+    def pack(self) -> bytes:
+        ...
+
+    def pack_into(self, buffer: Buffer, offset=0) -> None:
+        ...
+
+    @classmethod
+    def unpack(cls, buffer) -> Self:
+        ...
+
+    @classmethod
+    def unpack_from(cls, buffer, offset=0) -> Self:
+        ...
+
+    @classmethod
+    def iter_unpack(cls, buffer) -> Generator[Self, None, None]:
+        ...
+
+    @classmethod
+    def iter_unpack_reused(cls, buffer) -> Generator[Self, None, None]:
+        ...
+
+    def update_from(self, buffer: Buffer, offset=0) -> None:
+        ...
+
+    def to_dict(self):
+        return {
+            k: getattr(self, k)
+            for k in self.__ost_fields__
+        }
+
+    def __str__(self):
+        dct = self.to_dict()
+        kv_string = ', '.join(
+            map(
+                lambda x: f"{x[0]}={x[1]!r}"
+                , dct.items()
+            )
+        )
+        return f'{self.__class__.__name__}' f"({kv_string})"
+
+    def __repr__(self):
+        dct = self.to_dict()
+        kv_string = ', '.join(
+            map(
+                lambda x: f"{x[0]}={x[1]!r}"
+                , dct.items()
+            )
+        )
+        return f'{self.__class__.__name__}[{self.__st_format__}]' f"({kv_string})"

hydrogenlib_objective_struct-0.0.1/src/_hydrogenlib_objective_struct/types/__init__.py

@@ -0,0 +1,14 @@
+import builtins
+
+from .types import *
+
+
+def get_ctype(cls):
+    try:
+        return cls.__ctype__
+    except AttributeError:
+        return {
+            builtins.int: 'i',
+            builtins.float: 'f',
+            builtins.bool: '?',
+        }[cls]

hydrogenlib_objective_struct-0.0.1/src/_hydrogenlib_objective_struct/types/base.py

@@ -0,0 +1,6 @@
+def make_struct_type[T](name, pytype: type[T], ctype) -> type[T]:
+    return type(
+        name, (pytype,), {
+            '__ctype__': ctype
+        }
+    )

hydrogenlib_objective_struct-0.0.1/src/_hydrogenlib_objective_struct/types/types.py

@@ -0,0 +1,101 @@
+import builtins
+import sys
+from functools import lru_cache
+
+from .base import make_struct_type
+
+
+@lru_cache(maxsize=32)
+def pad(size: int):
+    return make_struct_type(
+        f'pad_{size}', builtins.bytes, f'{size}x'
+    )
+
+
+char = make_struct_type(
+    'char', builtins.bytes, 'c'
+)
+
+signed_char = make_struct_type(
+    'signed_char', builtins.int, 'b'
+)
+
+unsigned_char = make_struct_type(
+    'unsigned_char', builtins.int, 'B'
+)
+
+# bool = make_struct_type(
+#     'bool', builtins.int, '?'
+# )  # 布尔类型不能添加子类，也不允许添加新的类属性，只能特殊处理
+
+short = make_struct_type(
+    'short', builtins.int, 'h'
+)
+
+unsigned_short = make_struct_type(
+    'unsigned_short', builtins.int, 'H'
+)
+
+unsigned_int = make_struct_type(
+    'unsigned_int', builtins.int, 'I'
+)
+
+long = make_struct_type(
+    'long', builtins.int, 'l'
+)
+
+unsigned_long = make_struct_type(
+    'unsigned_long', builtins.int, 'L'
+)
+
+long_long = make_struct_type(
+    'long_long', builtins.int, 'q'
+)
+
+unsigned_long_long = make_struct_type(
+    'unsigned_long_long', builtins.int, 'Q'
+)
+
+double = make_struct_type(
+    'double', builtins.float, 'd'
+)
+
+short_float = make_struct_type(
+    'short_float', builtins.float, 'e'
+)
+
+size_t = make_struct_type(
+    'size_t', builtins.int, 'n'
+)
+
+ssize_t = make_struct_type(
+    'ssize_t', builtins.int, 'N'
+)
+
+
+# string (char[]), length must be specified when used
+@lru_cache(maxsize=32)
+def string(length):
+    return make_struct_type(f'string_{length}', builtins.bytes, f'{length}s')
+
+
+# pascal string (length-prefixed)
+@lru_cache(maxsize=32)
+def pascal_string(length):
+    return make_struct_type(f'pascal_string_{length}', builtins.bytes, f'{length}p')
+
+
+# pointer-sized integer (platform dependent)
+pointer = make_struct_type(
+    'pointer', builtins.int, 'P'
+)
+
+# >= 3.14
+if sys.version_info.major >= 3 and sys.version_info.minor >= 14:
+    float_complex = make_struct_type(
+        'complex', builtins.complex, 'F'
+    )
+
+    double_complex = make_struct_type(
+        'double_complex', builtins.complex, 'D'
+    )

hydrogenlib_objective_struct-0.0.1/src/_hydrogenlib_objective_struct/types/types.pyi

@@ -0,0 +1,69 @@
+import sys
+
+
+class _ctype:
+    __ctype__: str
+
+
+def pad(size: int) -> type: ...
+
+
+class char(bytes, _ctype): ...
+
+
+class signed_char(int, _ctype): ...
+
+
+class unsigned_char(int, _ctype): ...
+
+
+class long(int, _ctype): ...
+
+
+class unsigned_long(int, _ctype): ...
+
+
+class short(int, _ctype): ...
+
+
+class unsigned_short(int, _ctype): ...
+
+
+class unsigned_int(int, _ctype): ...
+
+
+class long_long(int, _ctype): ...
+
+
+class unsigned_long_long(int, _ctype): ...
+
+
+class double(float, _ctype): ...
+
+
+class short_double(float, _ctype): ...
+
+
+class short_float(float, _ctype): ...
+
+
+class size_t(int, _ctype): ...
+
+
+class ssize_t(int, _ctype): ...
+
+
+def string(length: int) -> type[bytes]: ...
+
+
+def pascal_string(length: int) -> type[bytes]: ...
+
+
+class pointer(int, _ctype): ...
+
+
+if sys.version_info >= (3, 14, 0):
+    class float_complex(complex, _ctype): ...
+
+
+    class double_complex(complex, _ctype): ...