dissect.cstruct 4.4.dev2__py3-none-any.whl → 4.5.dev1__py3-none-any.whl

dissect/cstruct/types/int.py

@@ -1,10 +1,13 @@
 from __future__ import annotations
 
-from typing import Any, BinaryIO
+from typing import TYPE_CHECKING, Any, BinaryIO
 
 from dissect.cstruct.types.base import BaseType
 from dissect.cstruct.utils import ENDIANNESS_MAP
 
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
 
 class Int(int, BaseType):
     """Integer type that can span an arbitrary amount of bytes."""
@@ -12,7 +15,7 @@ class Int(int, BaseType):
     signed: bool
 
     @classmethod
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Int:
+    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Self:
         data = stream.read(cls.size)
 
         if len(data) != cls.size:
@@ -21,7 +24,7 @@ class Int(int, BaseType):
         return cls.from_bytes(data, ENDIANNESS_MAP[cls.cs.endian], signed=cls.signed)
 
     @classmethod
-    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Int:
+    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Self:
         result = []
 
         while True:

dissect/cstruct/types/leb128.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
-from typing import Any, BinaryIO
+from typing import TYPE_CHECKING, Any, BinaryIO
 
 from dissect.cstruct.types.base import BaseType
 
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
 
 class LEB128(int, BaseType):
     """Variable-length code compression to store an arbitrarily large integer in a small number of bytes.
@@ -14,7 +17,7 @@ class LEB128(int, BaseType):
     signed: bool
 
     @classmethod
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> LEB128:
+    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Self:
         result = 0
         shift = 0
         while True:
@@ -34,7 +37,7 @@ class LEB128(int, BaseType):
         return cls.__new__(cls, result)
 
     @classmethod
-    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> LEB128:
+    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> list[Self]:
         result = []
 
         while True:

dissect/cstruct/types/packed.py

@@ -2,27 +2,33 @@ from __future__ import annotations
 
 from functools import lru_cache
 from struct import Struct
-from typing import Any, BinaryIO
+from typing import TYPE_CHECKING, Any, BinaryIO, Generic, TypeVar
 
 from dissect.cstruct.types.base import EOF, BaseType
 
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
 
 @lru_cache(1024)
 def _struct(endian: str, packchar: str) -> Struct:
     return Struct(f"{endian}{packchar}")
 
 
-class Packed(BaseType):
+T = TypeVar("T", int, float)
+
+
+class Packed(BaseType, Generic[T]):
     """Packed type for Python struct (un)packing."""
 
     packchar: str
 
     @classmethod
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Packed:
+    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Self:
         return cls._read_array(stream, 1, context)[0]
 
     @classmethod
-    def _read_array(cls, stream: BinaryIO, count: int, context: dict[str, Any] | None = None) -> list[Packed]:
+    def _read_array(cls, stream: BinaryIO, count: int, context: dict[str, Any] | None = None) -> list[Self]:
         if count == EOF:
             data = stream.read()
             length = len(data)
@@ -39,7 +45,7 @@ class Packed(BaseType):
         return [cls.__new__(cls, value) for value in fmt.unpack(data)]
 
     @classmethod
-    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Packed:
+    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Self:
         result = []
 
         fmt = _struct(cls.cs.endian, cls.packchar)
@@ -57,9 +63,9 @@ class Packed(BaseType):
         return result
 
     @classmethod
-    def _write(cls, stream: BinaryIO, data: Packed) -> int:
+    def _write(cls, stream: BinaryIO, data: Packed[T]) -> int:
         return stream.write(_struct(cls.cs.endian, cls.packchar).pack(data))
 
     @classmethod
-    def _write_array(cls, stream: BinaryIO, data: list[Packed]) -> int:
+    def _write_array(cls, stream: BinaryIO, data: list[Packed[T]]) -> int:
         return stream.write(_struct(cls.cs.endian, f"{len(data)}{cls.packchar}").pack(*data))

dissect/cstruct/types/pointer.py

@@ -1,22 +1,27 @@
 from __future__ import annotations
 
-from typing import Any, BinaryIO
+from typing import TYPE_CHECKING, Any, BinaryIO, Generic, TypeVar
 
 from dissect.cstruct.exceptions import NullPointerDereference
-from dissect.cstruct.types.base import BaseType, MetaType
+from dissect.cstruct.types.base import BaseType
 from dissect.cstruct.types.char import Char
 from dissect.cstruct.types.void import Void
 
+if TYPE_CHECKING:
+    from typing_extensions import Self
 
-class Pointer(int, BaseType):
+T = TypeVar("T", bound=BaseType)
+
+
+class Pointer(int, BaseType, Generic[T]):
     """Pointer to some other type."""
 
-    type: MetaType
+    type: type[T]
     _stream: BinaryIO | None
     _context: dict[str, Any] | None
-    _value: BaseType
+    _value: T | None
 
-    def __new__(cls, value: int, stream: BinaryIO | None, context: dict[str, Any] | None = None) -> Pointer:  # noqa: PYI034
+    def __new__(cls, value: int, stream: BinaryIO | None, context: dict[str, Any] | None = None) -> Self:
         obj = super().__new__(cls, value)
         obj._stream = stream
         obj._context = context
@@ -32,52 +37,52 @@ class Pointer(int, BaseType):
     def __getattr__(self, attr: str) -> Any:
         return getattr(self.dereference(), attr)
 
-    def __add__(self, other: int) -> Pointer:
+    def __add__(self, other: int) -> Self:
         return type.__call__(self.__class__, int.__add__(self, other), self._stream, self._context)
 
-    def __sub__(self, other: int) -> Pointer:
+    def __sub__(self, other: int) -> Self:
         return type.__call__(self.__class__, int.__sub__(self, other), self._stream, self._context)
 
-    def __mul__(self, other: int) -> Pointer:
+    def __mul__(self, other: int) -> Self:
         return type.__call__(self.__class__, int.__mul__(self, other), self._stream, self._context)
 
-    def __floordiv__(self, other: int) -> Pointer:
+    def __floordiv__(self, other: int) -> Self:
         return type.__call__(self.__class__, int.__floordiv__(self, other), self._stream, self._context)
 
-    def __mod__(self, other: int) -> Pointer:
+    def __mod__(self, other: int) -> Self:
         return type.__call__(self.__class__, int.__mod__(self, other), self._stream, self._context)
 
-    def __pow__(self, other: int) -> Pointer:
+    def __pow__(self, other: int) -> Self:
         return type.__call__(self.__class__, int.__pow__(self, other), self._stream, self._context)
 
-    def __lshift__(self, other: int) -> Pointer:
+    def __lshift__(self, other: int) -> Self:
         return type.__call__(self.__class__, int.__lshift__(self, other), self._stream, self._context)
 
-    def __rshift__(self, other: int) -> Pointer:
+    def __rshift__(self, other: int) -> Self:
         return type.__call__(self.__class__, int.__rshift__(self, other), self._stream, self._context)
 
-    def __and__(self, other: int) -> Pointer:
+    def __and__(self, other: int) -> Self:
         return type.__call__(self.__class__, int.__and__(self, other), self._stream, self._context)
 
-    def __xor__(self, other: int) -> Pointer:
+    def __xor__(self, other: int) -> Self:
         return type.__call__(self.__class__, int.__xor__(self, other), self._stream, self._context)
 
-    def __or__(self, other: int) -> Pointer:
+    def __or__(self, other: int) -> Self:
         return type.__call__(self.__class__, int.__or__(self, other), self._stream, self._context)
 
     @classmethod
-    def __default__(cls) -> Pointer:
+    def __default__(cls) -> Self:
         return cls.__new__(cls, cls.cs.pointer.__default__(), None, None)
 
     @classmethod
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Pointer:
+    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Self:
         return cls.__new__(cls, cls.cs.pointer._read(stream, context), stream, context)
 
     @classmethod
     def _write(cls, stream: BinaryIO, data: int) -> int:
         return cls.cs.pointer._write(stream, data)
 
-    def dereference(self) -> Any:
+    def dereference(self) -> T:
         if self == 0 or self._stream is None:
             raise NullPointerDereference
 

dissect/cstruct/types/structure.py

@@ -7,6 +7,7 @@ from functools import lru_cache
 from itertools import chain
 from operator import attrgetter
 from textwrap import dedent
+from types import FunctionType
 from typing import TYPE_CHECKING, Any, BinaryIO, Callable
 
 from dissect.cstruct.bitbuffer import BitBuffer
@@ -23,12 +24,15 @@ if TYPE_CHECKING:
     from collections.abc import Iterator
     from types import FunctionType
 
+    from typing_extensions import Self
+
 
 class Field:
     """Structure field."""
 
-    def __init__(self, name: str, type_: MetaType, bits: int | None = None, offset: int | None = None):
-        self.name = name
+    def __init__(self, name: str | None, type_: type[BaseType], bits: int | None = None, offset: int | None = None):
+        self.name = name  # The name of the field, or None if anonymous
+        self._name = name or type_.__name__  # The name of the field, or the type name if anonymous
         self.type = type_
         self.bits = bits
         self.offset = offset
@@ -57,13 +61,13 @@ class StructureMetaType(MetaType):
     __updating__ = False
     __compiled__ = False
 
-    def __new__(metacls, name: str, bases: tuple[type, ...], classdict: dict[str, Any]) -> MetaType:
+    def __new__(metacls, name: str, bases: tuple[type, ...], classdict: dict[str, Any]) -> Self:  # type: ignore
         if (fields := classdict.pop("fields", None)) is not None:
             metacls._update_fields(metacls, fields, align=classdict.get("__align__", False), classdict=classdict)
 
         return super().__new__(metacls, name, bases, classdict)
 
-    def __call__(cls, *args, **kwargs) -> Structure:
+    def __call__(cls, *args, **kwargs) -> Self:  # type: ignore
         if (
             cls.__fields__
             and len(args) == len(cls.__fields__) == 1
@@ -81,26 +85,28 @@ class StructureMetaType(MetaType):
 
         return super().__call__(*args, **kwargs)
 
-    def _update_fields(cls, fields: list[Field], align: bool = False, classdict: dict[str, Any] | None = None) -> None:
+    def _update_fields(
+        cls, fields: list[Field], align: bool = False, classdict: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
         classdict = classdict or {}
 
         lookup = {}
         raw_lookup = {}
         field_names = []
         for field in fields:
-            if field.name in lookup and field.name != "_":
-                raise ValueError(f"Duplicate field name: {field.name}")
+            if field._name in lookup and field._name != "_":
+                raise ValueError(f"Duplicate field name: {field._name}")
 
-            if isinstance(field.type, StructureMetaType) and field.type.__anonymous__:
+            if isinstance(field.type, StructureMetaType) and field.name is None:
                 for anon_field in field.type.fields.values():
-                    attr = f"{field.name}.{anon_field.name}"
+                    attr = f"{field._name}.{anon_field.name}"
                     classdict[anon_field.name] = property(attrgetter(attr), attrsetter(attr))
 
                 lookup.update(field.type.fields)
             else:
-                lookup[field.name] = field
+                lookup[field._name] = field
 
-            raw_lookup[field.name] = field
+            raw_lookup[field._name] = field
 
         field_names = lookup.keys()
         classdict["fields"] = lookup
@@ -133,7 +139,7 @@ class StructureMetaType(MetaType):
                 classdict["__compiled__"] = True
             except Exception:
                 # Revert _read to the slower loop based method
-                classdict["_read"] = classmethod(StructureMetaType._read)
+                classdict["_read"] = classmethod(Structure._read.__func__)
                 classdict["__compiled__"] = False
 
         # TODO: compile _write
@@ -233,7 +239,7 @@ class StructureMetaType(MetaType):
         # The structure size is whatever the currently calculated offset is
         return offset, alignment
 
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Structure:
+    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Self:  # type: ignore
         bit_buffer = BitBuffer(stream, cls.cs.endian)
         struct_start = stream.tell()
 
@@ -241,7 +247,6 @@ class StructureMetaType(MetaType):
         sizes = {}
         for field in cls.__fields__:
             offset = stream.tell()
-            field_type = cls.cs.resolve(field.type)
 
             if field.offset is not None and offset != struct_start + field.offset:
                 # Field is at a specific offset, either alligned or added that way
@@ -254,21 +259,20 @@ class StructureMetaType(MetaType):
                 stream.seek(offset)
 
             if field.bits:
-                if isinstance(field_type, EnumMetaType):
-                    value = field_type(bit_buffer.read(field_type.type, field.bits))
+                if isinstance(field.type, EnumMetaType):
+                    value = field.type(bit_buffer.read(field.type.type, field.bits))
                 else:
-                    value = bit_buffer.read(field_type, field.bits)
+                    value = bit_buffer.read(field.type, field.bits)
 
-                if field.name:
-                    result[field.name] = value
+                result[field._name] = value
                 continue
+
             bit_buffer.reset()
 
-            value = field_type._read(stream, result)
+            value = field.type._read(stream, result)
 
-            if field.name:
-                sizes[field.name] = stream.tell() - offset
-                result[field.name] = value
+            sizes[field._name] = stream.tell() - offset
+            result[field._name] = value
 
         if cls.__align__:
             # Align the stream
@@ -281,7 +285,7 @@ class StructureMetaType(MetaType):
         obj._values = result
         return obj
 
-    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> list[Structure]:
+    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> list[Self]:  # type: ignore
         result = []
 
         while obj := cls._read(stream, context):
@@ -325,7 +329,7 @@ class StructureMetaType(MetaType):
                     stream.write(b"\x00" * align_pad)
                     offset += align_pad
 
-            value = getattr(data, field.name, None)
+            value = getattr(data, field._name, None)
             if value is None:
                 value = field_type.__default__()
 
@@ -347,7 +351,7 @@ class StructureMetaType(MetaType):
 
         return num
 
-    def add_field(cls, name: str, type_: BaseType, bits: int | None = None, offset: int | None = None) -> None:
+    def add_field(cls, name: str, type_: type[BaseType], bits: int | None = None, offset: int | None = None) -> None:
         field = Field(name, type_, bits=bits, offset=offset)
         cls.__fields__.append(field)
 
@@ -401,7 +405,7 @@ class Structure(BaseType, metaclass=StructureMetaType):
 class UnionMetaType(StructureMetaType):
     """Base metaclass for cstruct union type classes."""
 
-    def __call__(cls, *args, **kwargs) -> Union:
+    def __call__(cls, *args, **kwargs) -> Self:  # type: ignore
         obj: Union = super().__call__(*args, **kwargs)
 
         # Calling with non-stream args or kwargs means we are initializing with values
@@ -412,7 +416,7 @@ class UnionMetaType(StructureMetaType):
 
             # User (partial) initialization, rebuild the union
             # First user-provided field is the one used to rebuild the union
-            arg_fields = (field.name for _, field in zip(args, cls.__fields__))
+            arg_fields = (field._name for _, field in zip(args, cls.__fields__))
             kwarg_fields = (name for name in kwargs if name in cls.lookup)
             if (first_field := next(chain(arg_fields, kwarg_fields), None)) is not None:
                 obj._rebuild(first_field)
@@ -469,12 +473,12 @@ class UnionMetaType(StructureMetaType):
             buf.seek(offset + start)
             value = field_type._read(buf, result)
 
-            sizes[field.name] = buf.tell() - start
-            result[field.name] = value
+            sizes[field._name] = buf.tell() - start
+            result[field._name] = value
 
         return result, sizes
 
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Union:
+    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Self:  # type: ignore
         if cls.size is None:
             start = stream.tell()
             result, sizes = cls._read_fields(stream, context)
@@ -517,13 +521,13 @@ class UnionMetaType(StructureMetaType):
 
         # Try to write by largest field
         for field in fields:
-            if isinstance(field.type, StructureMetaType) and field.type.__anonymous__:
+            if isinstance(field.type, StructureMetaType) and field.name is None:
                 # Prefer to write regular fields initially
                 anonymous_struct = field.type
                 continue
 
             # Write the value
-            field.type._write(stream, getattr(data, field.name))
+            field.type._write(stream, getattr(data, field._name))
             break
 
         # If we haven't written anything yet and we initially skipped an anonymous struct, write it now
@@ -582,9 +586,9 @@ class Union(Structure, metaclass=UnionMetaType):
         def _proxy_structure(value: Structure) -> None:
             for field in value.__class__.__fields__:
                 if issubclass(field.type, Structure):
-                    nested_value = getattr(value, field.name)
-                    proxy = UnionProxy(self, field.name, nested_value)
-                    object.__setattr__(value, field.name, proxy)
+                    nested_value = getattr(value, field._name)
+                    proxy = UnionProxy(self, field._name, nested_value)
+                    object.__setattr__(value, field._name, proxy)
                     _proxy_structure(nested_value)
 
         _proxy_structure(self)
@@ -771,7 +775,7 @@ def _generate_structure__init__(fields: list[Field]) -> FunctionType:
     Args:
         fields: List of field names.
     """
-    field_names = [field.name for field in fields]
+    field_names = [field._name for field in fields]
 
     template: FunctionType = _make_structure__init__(len(field_names))
     return type(template)(
@@ -791,12 +795,15 @@ def _generate_union__init__(fields: list[Field]) -> FunctionType:
     Args:
         fields: List of field names.
     """
-    field_names = [field.name for field in fields]
+    field_names = [field._name for field in fields]
 
     template: FunctionType = _make_union__init__(len(field_names))
     return type(template)(
         template.__code__.replace(
-            co_consts=(None, *sum([(field.name, field.type.__default__()) for field in fields], ())),
+            co_consts=(
+                None,
+                *sum([(field._name, field.type.__default__()) for field in fields], ()),
+            ),
             co_varnames=("self", *field_names),
         ),
         template.__globals__,

dissect/cstruct/types/wchar.py

@@ -3,17 +3,21 @@ from __future__ import annotations
 import sys
 from typing import Any, BinaryIO, ClassVar
 
-from dissect.cstruct.types.base import EOF, ArrayMetaType, BaseType
+from dissect.cstruct.types.base import EOF, BaseArray, BaseType
 
 
-class WcharArray(str, BaseType, metaclass=ArrayMetaType):
+class WcharArray(str, BaseArray):
     """Wide-character array type for reading and writing UTF-16 strings."""
 
     __slots__ = ()
 
+    @classmethod
+    def __default__(cls) -> WcharArray:
+        return type.__call__(cls, "\x00" * (0 if cls.dynamic or cls.null_terminated else cls.num_entries))
+
     @classmethod
     def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> WcharArray:
-        return type.__call__(cls, ArrayMetaType._read(cls, stream, context))
+        return type.__call__(cls, super()._read(stream, context))
 
     @classmethod
     def _write(cls, stream: BinaryIO, data: str) -> int:
@@ -21,10 +25,6 @@ class WcharArray(str, BaseType, metaclass=ArrayMetaType):
             data += "\x00"
         return stream.write(data.encode(Wchar.__encoding_map__[cls.cs.endian]))
 
-    @classmethod
-    def __default__(cls) -> WcharArray:
-        return type.__call__(cls, "\x00" * (0 if cls.dynamic or cls.null_terminated else cls.num_entries))
-
 
 class Wchar(str, BaseType):
     """Wide-character type for reading and writing UTF-16 characters."""
@@ -40,6 +40,10 @@ class Wchar(str, BaseType):
         "!": "utf-16-be",
     }
 
+    @classmethod
+    def __default__(cls) -> Wchar:
+        return type.__call__(cls, "\x00")
+
     @classmethod
     def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Wchar:
         return cls._read_array(stream, 1, context)
@@ -76,7 +80,3 @@ class Wchar(str, BaseType):
     @classmethod
     def _write(cls, stream: BinaryIO, data: str) -> int:
         return stream.write(data.encode(cls.__encoding_map__[cls.cs.endian]))
-
-    @classmethod
-    def __default__(cls) -> Wchar:
-        return type.__call__(cls, "\x00")

dissect/cstruct/utils.py

@@ -11,6 +11,7 @@ from dissect.cstruct.types.structure import Structure
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
+    from typing import Literal
 
 COLOR_RED = "\033[1;31m"
 COLOR_GREEN = "\033[1;32m"
@@ -31,7 +32,7 @@ COLOR_BG_WHITE = "\033[1;47m\033[1;30m"
 
 PRINTABLE = string.digits + string.ascii_letters + string.punctuation + " "
 
-ENDIANNESS_MAP = {
+ENDIANNESS_MAP: dict[str, Literal["big", "little"]] = {
     "@": sys.byteorder,
     "=": sys.byteorder,
     "<": "little",
@@ -40,7 +41,7 @@ ENDIANNESS_MAP = {
     "network": "big",
 }
 
-Palette = list[tuple[str, str]]
+Palette = list[tuple[int, str]]
 
 
 def _hexdump(data: bytes, palette: Palette | None = None, offset: int = 0, prefix: str = "") -> Iterator[str]:
@@ -158,10 +159,10 @@ def _dumpstruct(
 
         if color:
             foreground, background = colors[ci % len(colors)]
-            palette.append((structure._sizes[field.name], background))
+            palette.append((structure._sizes[field._name], background))
         ci += 1
 
-        value = getattr(structure, field.name)
+        value = getattr(structure, field._name)
         if isinstance(value, (str, Pointer, Enum)):
             value = repr(value)
         elif isinstance(value, int):
@@ -169,12 +170,12 @@ def _dumpstruct(
         elif isinstance(value, list):
             value = pprint.pformat(value)
             if "\n" in value:
-                value = value.replace("\n", f"\n{' ' * (len(field.name) + 4)}")
+                value = value.replace("\n", f"\n{' ' * (len(field._name) + 4)}")
 
         if color:
-            out.append(f"- {foreground}{field.name}{COLOR_NORMAL}: {value}")
+            out.append(f"- {foreground}{field._name}{COLOR_NORMAL}: {value}")
         else:
-            out.append(f"- {field.name}: {value}")
+            out.append(f"- {field._name}: {value}")
 
     out = "\n".join(out)
 
@@ -184,7 +185,7 @@ def _dumpstruct(
         print()
         print(out)
     elif output == "string":
-        return "\n".join(["", hexdump(data, palette, offset=offset, output="string"), "", out])
+        return f"\n{hexdump(data, palette, offset=offset, output='string')}\n\n{out}"
     return None
 
 
@@ -210,7 +211,7 @@ def dumpstruct(
 
     if isinstance(obj, Structure):
         return _dumpstruct(obj, obj.dumps(), offset, color, output)
-    if issubclass(obj, Structure) and data:
+    if issubclass(obj, Structure) and data is not None:
         return _dumpstruct(obj(data), data, offset, color, output)
     raise ValueError("Invalid arguments")
 

{dissect.cstruct-4.4.dev2.dist-info → dissect_cstruct-4.5.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: dissect.cstruct
-Version: 4.4.dev2
+Version: 4.5.dev1
 Summary: A Dissect module implementing a parser for C-like structures: structure parsing in Python made easy
 Author-email: Dissect Team <dissect@fox-it.com>
 License: Apache License 2.0
@@ -22,6 +22,9 @@ Requires-Python: ~=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: COPYRIGHT
+Provides-Extra: dev
+Requires-Dist: typing_extensions; extra == "dev"
+Dynamic: license-file
 
 # dissect.cstruct
 

dissect_cstruct-4.5.dev1.dist-info/RECORD

@@ -0,0 +1,29 @@
+dissect/cstruct/__init__.py,sha256=mILXFvtajLG5EqAPSeCJ2g5klZSnRbu7uqyGcH_DF2k,1344
+dissect/cstruct/bitbuffer.py,sha256=bid_N4ZsaTeC3x5Fzs8viUrldT863dMPtEDih20Nt6k,2644
+dissect/cstruct/compiler.py,sha256=luyUXwPlOXFKRoqztNFY7YeENk_WEjsponvNfnjMKT4,14053
+dissect/cstruct/cstruct.py,sha256=IVvue9unr0T-ZZXSVM9mjIovwG4YdopKOqktmB8vIDk,19379
+dissect/cstruct/exceptions.py,sha256=WqsUW4OiIpRLQLvixfLrfKl0rtvU1qx7pvfBrz9Sz-I,293
+dissect/cstruct/expression.py,sha256=BJeQJYKwTvoDOIuv48rtfDp1kvyAjIkxpy2-VZMZ7Gc,10870
+dissect/cstruct/parser.py,sha256=v_D6x46J1EB3EJF5OssLf8nedYcShpQke4FJK4G7AyU,20910
+dissect/cstruct/utils.py,sha256=yItxcZ-IG9EZGABXap0456Y3LjLjh8zNEd5KOBD7YmU,10525
+dissect/cstruct/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dissect/cstruct/tools/stubgen.py,sha256=Cg_nHTp-KMm7eI0kCCeWflaYXeCGDFn728IdX60o508,7332
+dissect/cstruct/types/__init__.py,sha256=e9Z6BhhAPquT4MJoK3i_SjC9AgIGWFH_-tAVFCFBiqE,847
+dissect/cstruct/types/base.py,sha256=UFDolAxpVW1W9JoVlykEf96wBzt_suXvuYy08iB54Sw,9677
+dissect/cstruct/types/char.py,sha256=9XYCjCF0D_5o3EYnmIcjev-5GI2NzxOhd1ct1xF6SAM,2457
+dissect/cstruct/types/enum.py,sha256=9mzlIeHYLHOdNtTmiPgGNvGBYe71HeDX5qQDspX5O80,7409
+dissect/cstruct/types/flag.py,sha256=7xxQjFEDPHSQOxBHgcc75WzPiAxflOquwr7Z7c3erLE,2347
+dissect/cstruct/types/int.py,sha256=MGsdUxJt-lj3nl9wzAgGX8cb_vJOtGLiCHwYZs1j_IA,1156
+dissect/cstruct/types/leb128.py,sha256=kDmsWGXX6vr1bm4uJcilsrQ7JABdQRio16rBZV21pno,2243
+dissect/cstruct/types/packed.py,sha256=tpZpb8tiSMXr1np6p0-nZqT4sY7zieO-4E16lmMmqJA,2128
+dissect/cstruct/types/pointer.py,sha256=PqeJOoNBUfMd5uO2kpF6OHeW7Q6R1N1W1V4q1MakN4I,3912
+dissect/cstruct/types/structure.py,sha256=6OBxXr7hMYhufe4GvHkBHpME1fvJQYlfbFxchouHIIc,29814
+dissect/cstruct/types/void.py,sha256=VL2qJ86rq-oBUnkBprNsPPgPGgHV6UENRJTQ2jw0rxc,669
+dissect/cstruct/types/wchar.py,sha256=N9Y_XX2_hZEe2DwepJjxsB6xuRJ6zINRalcUofR59kY,2608
+dissect_cstruct-4.5.dev1.dist-info/licenses/COPYRIGHT,sha256=H-18RXfshdH9AdHwW2eO1Xa-5s6tY5eipHh5c0whDu4,316
+dissect_cstruct-4.5.dev1.dist-info/licenses/LICENSE,sha256=PhUqiw6jAh2KbBdVRPBq_hfAvfcTBin7nZ3CK7NQbTM,11341
+dissect_cstruct-4.5.dev1.dist-info/METADATA,sha256=eeA43wdx2j8YrTB3tP3fda3_Iv1NsMkIbbhW1ThT53g,8649
+dissect_cstruct-4.5.dev1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+dissect_cstruct-4.5.dev1.dist-info/entry_points.txt,sha256=z53zqZqwD2OLrAkRwrP4wTeiU9CQe7xrMly0T2c0_wQ,71
+dissect_cstruct-4.5.dev1.dist-info/top_level.txt,sha256=Mn-CQzEYsAbkxrUI0TnplHuXnGVKzxpDw_po_sXpvv4,8
+dissect_cstruct-4.5.dev1.dist-info/RECORD,,

{dissect.cstruct-4.4.dev2.dist-info → dissect_cstruct-4.5.dev1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

dissect_cstruct-4.5.dev1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cstruct-stubgen = dissect.cstruct.tools.stubgen:main