obstruct 0.2.4__tar.gz → 0.2.6__tar.gz

{obstruct-0.2.4 → obstruct-0.2.6}/.idea/workspace.xml

@@ -4,13 +4,9 @@
     <option name="autoReloadType" value="SELECTIVE" />
   </component>
   <component name="ChangeListManager">
-    <list default="true" id="b482b6b4-48ce-4be1-bf3c-a72ec254fa35" name="更改" comment="修正了一些命名">
-      <change beforePath="$PROJECT_DIR$/README.md" beforeDir="false" afterPath="$PROJECT_DIR$/README.md" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/obstruct/aot/base.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/obstruct/aot/base.py" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/obstruct/aot/pack.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/obstruct/aot/pack.py" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/obstruct/aot/unpack.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/obstruct/aot/unpack.py" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/obstruct/methods.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/obstruct/methods.py" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/test_speed.py" beforeDir="false" afterPath="$PROJECT_DIR$/test/test_speed.py" afterDir="false" />
+    <list default="true" id="b482b6b4-48ce-4be1-bf3c-a72ec254fa35" name="更改" comment="增强 array 类型的支持 x2">
+      <change beforePath="$PROJECT_DIR$/src/obstruct/__version__.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/obstruct/__version__.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/obstruct/struct_type.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/obstruct/struct_type.py" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
     <option name="HIGHLIGHT_CONFLICTS" value="true" />
@@ -171,7 +167,23 @@
       <option name="project" value="LOCAL" />
       <updated>1786870314349</updated>
     </task>
-    <option name="localTasksCounter" value="5" />
+    <task id="LOCAL-00005" summary="增强 array 类型的支持">
+      <option name="closed" value="true" />
+      <created>1786875274813</created>
+      <option name="number" value="00005" />
+      <option name="presentableId" value="LOCAL-00005" />
+      <option name="project" value="LOCAL" />
+      <updated>1786875274813</updated>
+    </task>
+    <task id="LOCAL-00006" summary="增强 array 类型的支持 x2">
+      <option name="closed" value="true" />
+      <created>1786883898686</created>
+      <option name="number" value="00006" />
+      <option name="presentableId" value="LOCAL-00006" />
+      <option name="project" value="LOCAL" />
+      <updated>1786883898686</updated>
+    </task>
+    <option name="localTasksCounter" value="7" />
     <servers />
   </component>
   <component name="TypeScriptGeneratedFilesManager">
@@ -193,6 +205,8 @@
     <MESSAGE value="增强类型系统，撰写 README.md" />
     <MESSAGE value="补充：基准测试脚本" />
     <MESSAGE value="修正了一些命名" />
-    <option name="LAST_COMMIT_MESSAGE" value="修正了一些命名" />
+    <MESSAGE value="增强 array 类型的支持" />
+    <MESSAGE value="增强 array 类型的支持 x2" />
+    <option name="LAST_COMMIT_MESSAGE" value="增强 array 类型的支持 x2" />
   </component>
 </project>

{obstruct-0.2.4 → obstruct-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: obstruct
-Version: 0.2.4
+Version: 0.2.6
 Author-email: LittleNightSong <LittleNightSongYO@outlook.com>
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Python

{obstruct-0.2.4 → obstruct-0.2.6}/src/obstruct/__init__.py

@@ -1,4 +1,3 @@
 from .methods import pack, unpack
-from .decorator import struct
 from .struct_type import Struct
 from .types import *

obstruct-0.2.6/src/obstruct/__version__.py

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

{obstruct-0.2.4 → obstruct-0.2.6}/src/obstruct/aot/base.py

@@ -5,7 +5,6 @@ import itertools
 import typing
 from typing import Any
 
-from obstruct.methods import get_ctype
 
 
 class _objective_node_operator:
@@ -31,6 +30,9 @@ class _objective_node_operator:
             self._node.body.append(tree)
             return tree
 
+    def add_codes(self, codes: typing.Iterable[str]):
+        [self.add_code(c) for c in codes]
+
     def insert_code(self, index, code: str):
         tree = ast.parse(code)
         if isinstance(tree, ast.Module):
@@ -135,6 +137,7 @@ def get_array_spec(tp):
 
 
 def get_array_ctype(tp) -> str | None | Any:
+    from obstruct.methods import get_ctype
     return get_ctype(get_array_spec(tp)[0])
 
 

{obstruct-0.2.4 → obstruct-0.2.6}/src/obstruct/aot/pack.py

@@ -6,16 +6,16 @@ import typing
 
 from .base import unique_name_generator, is_struct, is_array, get_array_ctype, to_tuple_expression, function_def, \
     get_array_length
-from ..methods import get_ctype
 
 if typing.TYPE_CHECKING:
     from .. import struct_type
 
 
-def create_pack_methods(cls: struct_type.Struct):
+def create_pack_methods(cls: type[struct_type.Struct]):
     """
     Generate `pack` and `pack_into` method
     """
+    from obstruct.methods import get_ctype
     with (
         function_def('pack(self)') as pack,
         function_def('pack_into(self, buffer, offset=0)') as pack_into,
@@ -24,8 +24,6 @@ def create_pack_methods(cls: struct_type.Struct):
         flat_fields = []
         array_fields = []
 
-        pack_into.add_code('buffer = memoryview(buffer)')
-
         def add_code(code):
             pack.add_code(code)
             pack_into.add_code(code)
@@ -62,6 +60,7 @@ def create_pack_methods(cls: struct_type.Struct):
         expression = to_tuple_expression(flat_fields, prefix='')
 
         if array_fields:  # 如果有数组字段，我们需要手动操作缓冲区
+            pack_into.insert_code(0, "buffer = memoryview(buffer)")
             pack.add_code(f"buffer = bytearray({cls.__cstruct__.size})")  # 初始化缓冲区
             for array_name, offset, size in array_fields:
                 add_code(f"buffer[{offset}:{offset + size}] = memoryview({array_name}).cast('B')")
@@ -72,8 +71,8 @@ def create_pack_methods(cls: struct_type.Struct):
             pack.add_return(f"_pack({expression})")
 
         pack_into.add_code(f"_pack_into(buffer, offset, {expression})")
-        print(pack.generate_code())  # Debug
-        print(pack_into.generate_code())  # Debug
+        # print(pack.generate_code())  # Debug
+        # print(pack_into.generate_code())  # Debug
         return (
             pack.exec({'_pack': cls.__cstruct__.pack, '_pack_into': cls.__cstruct__.pack_into, 'array': array.array}),
             pack_into.exec({'_pack_into': cls.__cstruct__.pack_into, 'array': array.array})

{obstruct-0.2.4 → obstruct-0.2.6}/src/obstruct/aot/unpack.py

@@ -5,13 +5,14 @@ import struct
 import typing
 
 from .base import unique_name_generator, is_struct, is_array, get_array_ctype, function_def, for_stmt, get_array_length
-from ..methods import get_ctype
 
 if typing.TYPE_CHECKING:
     from .. import struct_type
 
 
 def create_unpack_methods(cls: type[struct_type.Struct]):
+    from ..methods import get_ctype
+
     with (
         function_def('unpack(cls, buffer)') as unpack,
         function_def('update(self, buffer)') as update,
@@ -32,7 +33,7 @@ def create_unpack_methods(cls: type[struct_type.Struct]):
         def update_add_code(code):
             update.add_code(code)
             update_from.add_code(code)
-            iter_update_inner.add_code(code)
+            iter_update.insert_code(1, code)
 
         def unpack_add_code(code):
             unpack.add_code(code)
@@ -42,10 +43,10 @@ def create_unpack_methods(cls: type[struct_type.Struct]):
         assigns = []  # 赋值目标列表
         inner_classes = {}  # 内嵌的结构体的类型映射（所有内嵌结构体的类型在生成代码时都会被代替为无意义的名称）
 
-        iter_update.add_code("self = cls() if obj is None else obj")
+        iter_update.add_code("self = __new__(cls) if obj is None else obj")
 
-        iter_unpack_inner = for_stmt("values in _iter_unpack(buffer)")
-        iter_update_inner = for_stmt("values in _iter_unpack(buffer)")
+        iter_unpack_inner = for_stmt("i, values in enumerate(_iter_unpack(buffer))")
+        iter_update_inner = for_stmt("i, values in enumerate(_iter_unpack(buffer))")
 
         iter_unpack.add_node(iter_unpack_inner.node)
         iter_update.add_node(iter_update_inner.node)
@@ -55,7 +56,6 @@ def create_unpack_methods(cls: type[struct_type.Struct]):
         def walk(fields, path, parent_name=None, current_class_name='cls', offset=0):
             name = 'self'
 
-
             if len(path) > 1:  # 在处理内嵌的结构体
                 name = next(ung)  # 临时变量的名称
                 update_add_code(f"{name} = {parent_name}.{path[-1]}")
@@ -68,6 +68,9 @@ def create_unpack_methods(cls: type[struct_type.Struct]):
             for field in fields:  # 遍历字段
                 field_xpath = f'{name}.{field.name}'
 
+                # ctype = get_ctype(field.type)
+                # print(f"当前字段：{field_xpath}，类型：{field.type} '{ctype}'，偏移量：{offset}+{struct.calcsize(ctype)}")
+
                 if is_struct(field.type):  # 是个内嵌的结构体
                     if field.type not in inner_classes:  # 如果这个内嵌的结构体类型不在已知的结构体中（没有分配类名称）
                         type_name = next(ung)  # 生成一个唯一的类名
@@ -76,16 +79,16 @@ def create_unpack_methods(cls: type[struct_type.Struct]):
                         type_name = inner_classes[field.type]  # 如果在，那么提取
 
                     walk(field.type.__cfields__, path + (field.name,), name, type_name, offset)
+                    offset += field.type.__cstruct__.size
 
                 elif is_array(field.type):
                     dtype = get_array_ctype(field.type)
                     nbytes = get_array_length(field.type) * struct.calcsize(dtype)
-                    array_fields.append((field_xpath, dtype, offset, nbytes))
-
+                    array_fields.append((next(ung), field_xpath, dtype, offset, nbytes))
+                    offset += nbytes
                 else:
                     assigns.append(field_xpath)
-
-                offset += struct.calcsize(get_ctype(field.type))
+                    offset += struct.calcsize(get_ctype(field.type))
 
         walk(cls.__cfields__, ('A',))
 
@@ -104,13 +107,40 @@ def create_unpack_methods(cls: type[struct_type.Struct]):
         unpack_from.add_code(assign_code)
         update_from.add_code(assign_code)
 
-        for field_xpath, dtype, offset, nbytes in array_fields:
-            codes = [
+        for n, field_xpath, dtype, offset, nbytes in array_fields:
+            size = cls.__cstruct__.size
+
+            update.add_codes([
+                f"{field_xpath}.clear()",
+                f"{field_xpath}.frombytes(buffer[{offset}:{offset + nbytes}])",
+            ])
+
+            update_from.add_codes([
+                f"{field_xpath}.clear()",
+                f"{field_xpath}.frombytes(buffer[{offset}+offset:{offset + nbytes}+offset])",
+            ])
+
+            unpack.add_codes([
+                f'{field_xpath} = _ = array({dtype!r})',
+                f'_.frombytes(buffer[{offset}:{offset + nbytes}])',
+            ])
+            unpack_from.add_codes([
                 f'{field_xpath} = _ = array({dtype!r})',
-                f'_.frombytes(buffer[{offset}:{offset+nbytes}])',
-            ]
-            for co in codes:
-                unpack.add_code(co)
+                f'_.frombytes(buffer[{offset}+offset:{offset + nbytes}+offset])',
+            ])
+
+            iter_update_inner.add_codes([
+                f'offset = {size} * i',
+                f'{n}.frombytes(buffer[{offset}+offset:{offset + nbytes}+offset])'
+            ])
+
+            iter_unpack_inner.add_codes([
+                f"{field_xpath} = _ = array({dtype!r})",
+                f"offset = i*{size}",
+                f"_.frombytes(buffer[{offset}+offset:{offset + nbytes}+offset])"
+            ])
+
+            iter_update.insert_code(1, f"{n} = {field_xpath} = array({dtype!r})")
 
         if array_fields:
             unpack.insert_code(0, 'buffer = memoryview(buffer)')
@@ -120,15 +150,18 @@ def create_unpack_methods(cls: type[struct_type.Struct]):
         unpack_from.add_return('self')
         update_from.add_return('self')
 
-        iter_unpack_inner.add_code('yield self')  # iter 方法是 yield，而非 return
+        iter_unpack_inner.add_code('yield self')
         iter_update_inner.add_code('yield self')
 
-        print(unpack.generate_code())
-        # print(update.generate_code())
-        # print(unpack_from.generate_code())
-        # print(update_from.generate_code())
-        # print(iter_unpack.generate_code())
-        # print(iter_update.generate_code())
+        for n, *_ in array_fields:
+            iter_update_inner.add_code(f'{n}.clear()')
+
+        # print(unpack.generate_code())
+        print(update.generate_code())
+        print(unpack_from.generate_code())
+        print(update_from.generate_code())
+        print(iter_unpack.generate_code())
+        print(iter_update.generate_code())
 
         globals = {
             v: k for k, v in inner_classes.items()  # 翻转字典
@@ -139,7 +172,8 @@ def create_unpack_methods(cls: type[struct_type.Struct]):
             _unpack=cls.__cstruct__.unpack,
             _unpack_from=cls.__cstruct__.unpack_from,
             _iter_unpack=cls.__cstruct__.iter_unpack,
-            array=array.array
+            array=array.array,
+            enumerate=enumerate
         ))
 
         return unpack.exec(

obstruct-0.2.6/src/obstruct/struct_type.py

@@ -0,0 +1,132 @@
+import dataclasses
+import struct
+import typing
+from collections.abc import Buffer
+from typing import Self, Generator, Any, ClassVar
+
+from obstruct.aot import create_pack_methods, create_unpack_methods
+
+
+class CType(typing.Protocol):
+    __ctype__: str
+
+
+class StructMeta(type):
+    __struct_methods__ = {
+        'pack',
+        'pack_into',
+
+        'unpack',
+        'unpack_from',
+        'iter_unpack',
+
+        'update',
+        'update_from',
+        'iter_update',
+
+        '__cstruct__',
+        '__ctype__',
+        '__cfields__',
+    }
+
+    def __new__(cls, name, bases, attrs, *, endian='little'):
+        slots = set(attrs.get('__slots__', ()))
+
+        annotations = attrs.get('__annotations__')
+
+        if annotations is None:
+            import annotationlib
+            annotate = annotationlib.get_annotate_from_class_namespace(attrs)
+            assert annotate is not None
+
+            annotations = annotationlib.call_annotate_function(
+                annotate,
+                format=annotationlib.Format.STRING
+            )
+
+        slots |= {k for k in annotations.keys() if not k.startswith('_')}
+
+        attrs['__slots__'] = slots
+        attrs['__cendian__'] = endian
+
+        return super().__new__(cls, name, bases, attrs)
+
+    def __compile_struct__(cls):
+        from obstruct.methods import to_format_string
+        fields = [i for i in dataclasses.fields(cls) if i.init]
+        real_annotations = typing.get_type_hints(cls)
+
+        for field in fields:
+            # print(cls, field.name, repr(field.type))
+            if isinstance(field.type, str):
+                field.type = real_annotations[field.name]
+
+        cls.__ctype__ = to_format_string([field.type for field in fields])
+        cls.__cfields__ = tuple(fields)  # type: tuple[dataclasses.Field, ...]
+        cls.__cstruct__ = struct.Struct(
+            endian_mapping.get(cls.__cendian__, cls.__cendian__) + cls.__ctype__)  # 构造 Struct 类型
+
+        cls.pack, cls.pack_into = create_pack_methods(cls)
+        cls.unpack, cls.update, cls.unpack_from, cls.update_from, cls.iter_unpack, cls.iter_update = (
+            create_unpack_methods(cls)
+        )
+
+
+endian_mapping = {
+    'little': '<',
+    'big': '>',
+    'machine': '=',
+    'network': '!'
+}
+
+
+class Struct(metaclass=StructMeta):
+    """
+    代表C语言结构体的Python类。
+    提供了将结构体对象与字节序列之间互相转换的功能，
+    包括打包、解包、更新等操作。
+    """
+
+    __cfields__: ClassVar[tuple[dataclasses.Field]]
+    __cstruct__: ClassVar[struct.Struct]
+    __cendian__: ClassVar[str]
+
+    if typing.TYPE_CHECKING:
+        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_update(cls, buffer) -> Generator[Self, None, None]:
+            ...
+
+        def update(self, buffer: Buffer) -> None:
+            ...
+
+        def update_from(self, buffer: Buffer, offset=0) -> None:
+            ...
+
+    def to_dict(self) -> dict[str, Any]:
+        return dataclasses.asdict(self)
+
+    def __getattr__(self, item):
+        ty = type(self)
+        if item in ty.__struct_methods__:
+            ty.__compile_struct__()
+            return getattr(self, item)
+
+        raise AttributeError(item)

{obstruct-0.2.4 → obstruct-0.2.6}/test/test_speed.py

@@ -6,8 +6,7 @@ from typing import Annotated
 import obstruct as obs
 
 
-@obs.struct()
-@dataclasses.dataclass(slots=True)
+@dataclasses.dataclass()
 class MyStruct(obs.Struct):
     a: int
     b: int
@@ -23,17 +22,26 @@ class MyStruct(obs.Struct):
     l: obs.long_long
 
 
-@obs.struct()
-@dataclasses.dataclass(slots=True)
+@dataclasses.dataclass()
 class AnotherStruct(obs.Struct):
     x: MyStruct
     y: Annotated[array[int], 100]
     z: MyStruct
 
 
+MyStruct.__compile_struct__()
+AnotherStruct.__compile_struct__()
+
+print('MyStruct size', MyStruct.__cstruct__.size)
+print('AnotherStruct size', AnotherStruct.__cstruct__.size)
+
+
+exit()
+
 data = MyStruct(
     1,2,1.0,4,5,6,7,8,9,b'8',1,2
 )
+
 packed_data = data.pack()
 
 

obstruct-0.2.4/src/obstruct/__version__.py

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

obstruct-0.2.4/src/obstruct/decorator.py

@@ -1,34 +0,0 @@
-import dataclasses
-import typing
-
-from . import struct_type
-from .aot import pack, unpack
-from .methods import to_format_string
-
-endian_control_characters = tuple('<@=!>')
-
-
-def struct(maybe_cls=None, *, endian='@'):
-    def decorator[T](cls: T) -> T:
-        import struct
-        fields = dataclasses.fields(cls)
-        real_annotations = typing.get_type_hints(cls)
-
-        for field in fields:
-            # print(cls, field.name, repr(field.type))
-            if isinstance(field.type, str):
-                field.type = real_annotations[field.name]
-
-        cls.__ctype__ = to_format_string([field.type for field in fields])
-        cls.__cfields__ = tuple(fields)  # type: tuple[dataclasses.Field, ...]
-        cls.__cstruct__ = struct.Struct(endian + cls.__ctype__)  # 构造 Struct 类型
-        cls.__cendian__ = endian
-
-        cls.pack, cls.pack_into = pack.create_pack_methods(cls)
-        cls.unpack, cls.update, cls.unpack_from, cls.update_from, cls.iter_unpack, cls.iter_update = (
-            unpack.create_unpack_methods(cls)
-        )
-
-        return cls
-
-    return decorator(maybe_cls) if maybe_cls is not None else decorator

obstruct-0.2.4/src/obstruct/struct_type.py

@@ -1,52 +0,0 @@
-import dataclasses
-import struct
-import typing
-from collections.abc import Buffer
-from typing import Self, Generator, Any, ClassVar
-
-
-class CType(typing.Protocol):
-    __ctype__: str
-
-
-class Struct(CType):
-    """
-    代表C语言结构体的Python类。
-    提供了将结构体对象与字节序列之间互相转换的功能，
-    包括打包、解包、更新等操作。
-    """
-
-    __cfields__: ClassVar[tuple[dataclasses.Field]]
-    __cstruct__: ClassVar[struct.Struct]
-    __cendian__: ClassVar[str]
-
-    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_update(cls, buffer) -> Generator[Self, None, None]:
-        ...
-
-    def update(self, buffer: Buffer) -> None:
-        ...
-
-    def update_from(self, buffer: Buffer, offset=0) -> None:
-        ...
-
-    def to_dict(self) -> dict[str, Any]:
-        return dataclasses.asdict(self)