dissect.cstruct 4.3.dev1__tar.gz → 4.4.dev1__tar.gz

{dissect_cstruct-4.3.dev1/dissect.cstruct.egg-info → dissect_cstruct-4.4.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: dissect.cstruct
-Version: 4.3.dev1
+Version: 4.4.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

{dissect_cstruct-4.3.dev1 → dissect_cstruct-4.4.dev1}/dissect/cstruct/compiler.py

@@ -6,8 +6,7 @@ import io
 import logging
 from enum import Enum
 from textwrap import dedent, indent
-from types import MethodType
-from typing import TYPE_CHECKING, Iterator
+from typing import TYPE_CHECKING
 
 from dissect.cstruct.bitbuffer import BitBuffer
 from dissect.cstruct.types import (
@@ -30,6 +29,9 @@ from dissect.cstruct.types.enum import EnumMetaType
 from dissect.cstruct.types.packed import _struct
 
 if TYPE_CHECKING:
+    from collections.abc import Iterator
+    from types import MethodType
+
     from dissect.cstruct.cstruct import cstruct
     from dissect.cstruct.types.structure import Field
 
@@ -127,8 +129,7 @@ class _ReadSourceGenerator:
 
         code = indent(dedent(preamble).lstrip() + read_code + dedent(outro), "    ")
 
-        template = f"def _read(cls, stream, context=None):\n{code}"
-        return template
+        return f"def _read(cls, stream, context=None):\n{code}"
 
     def _generate_fields(self) -> Iterator[str]:
         current_offset = 0
@@ -210,10 +211,9 @@ class _ReadSourceGenerator:
             else:
                 current_block.append(field)
 
-            if current_offset is not None and size is not None:
-                if not field.bits or (field.bits and bits_rollover):
-                    current_offset += size
-                    bits_rollover = False
+            if current_offset is not None and size is not None and (not field.bits or bits_rollover):
+                current_offset += size
+                bits_rollover = False
 
         yield from flush()
 

{dissect_cstruct-4.3.dev1 → dissect_cstruct-4.4.dev1}/dissect/cstruct/cstruct.py

@@ -4,7 +4,8 @@ import ctypes as _ctypes
 import struct
 import sys
 import types
-from typing import Any, BinaryIO, Iterator
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, BinaryIO
 
 from dissect.cstruct.exceptions import ResolveError
 from dissect.cstruct.expression import Expression
@@ -27,6 +28,9 @@ from dissect.cstruct.types import (
     Wchar,
 )
 
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
 
 class cstruct:
     """Main class of cstruct. All types are registered in here.
@@ -134,7 +138,6 @@ class cstruct:
             "unsigned __int32": "uint32",
             "unsigned __int64": "uint64",
             "unsigned __int128": "uint128",
-            "unsigned __int128": "uint128",
 
             "wchar_t": "wchar",
 
@@ -233,7 +236,7 @@ class cstruct:
         """
         self.add_type(name, self._make_type(name, (type_,), size, alignment=alignment, attrs=kwargs))
 
-    def load(self, definition: str, deftype: int = None, **kwargs) -> cstruct:
+    def load(self, definition: str, deftype: int | None = None, **kwargs) -> cstruct:
         """Parse structures from the given definitions using the given definition type.
 
         Definitions can be parsed using different parsers. Currently, there's
@@ -259,7 +262,7 @@ class cstruct:
 
         return self
 
-    def loadfile(self, path: str, deftype: int = None, **kwargs) -> None:
+    def loadfile(self, path: str, deftype: int | None = None, **kwargs) -> None:
         """Load structure definitions from a file.
 
         The given path will be read and parsed using the .load() function.
@@ -269,7 +272,7 @@ class cstruct:
             deftype: The definition type to parse the definitions with.
             **kwargs: Keyword arguments for parsers.
         """
-        with open(path) as fh:
+        with Path(path).open() as fh:
             self.load(fh.read(), deftype, **kwargs)
 
     def read(self, name: str, stream: BinaryIO) -> Any:
@@ -354,10 +357,10 @@ class cstruct:
 
         return self._make_type(name, bases, size, alignment=type_.alignment, attrs=attrs)
 
-    def _make_int_type(self, name: str, size: int, signed: bool, *, alignment: int = None) -> type[Int]:
+    def _make_int_type(self, name: str, size: int, signed: bool, *, alignment: int | None = None) -> type[Int]:
         return self._make_type(name, (Int,), size, alignment=alignment, attrs={"signed": signed})
 
-    def _make_packed_type(self, name: str, packchar: str, base: type, *, alignment: int = None) -> type[Packed]:
+    def _make_packed_type(self, name: str, packchar: str, base: type, *, alignment: int | None = None) -> type[Packed]:
         return self._make_type(
             name,
             (base, Packed),
@@ -414,8 +417,7 @@ def ctypes(structure: Structure) -> _ctypes.Structure:
         t = ctypes_type(field.type)
         fields.append((field.name, t))
 
-    tt = type(structure.name, (_ctypes.Structure,), {"_fields_": fields})
-    return tt
+    return type(structure.name, (_ctypes.Structure,), {"_fields_": fields})
 
 
 def ctypes_type(type_: MetaType) -> Any:

{dissect_cstruct-4.3.dev1 → dissect_cstruct-4.4.dev1}/dissect/cstruct/expression.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import string
-from typing import TYPE_CHECKING, Callable
+from typing import TYPE_CHECKING, Callable, ClassVar
 
 from dissect.cstruct.exceptions import ExpressionParserError, ExpressionTokenizerError
 
@@ -21,8 +21,7 @@ class ExpressionTokenizer:
     def equal(self, token: str, expected: str | set[str]) -> bool:
         if isinstance(expected, set):
             return token in expected
-        else:
-            return token == expected
+        return token == expected
 
     def alnum(self, token: str) -> bool:
         return token.isalnum()
@@ -88,7 +87,7 @@ class ExpressionTokenizer:
                 continue
 
             # If token is a single digit, keep looping over expression and build the number
-            elif self.match(self.digit, consume=False, append=False):
+            if self.match(self.digit, consume=False, append=False):
                 token += self.get_token()
                 self.consume()
 
@@ -154,7 +153,7 @@ class ExpressionTokenizer:
 class Expression:
     """Expression parser for calculations in definitions."""
 
-    binary_operators = {
+    binary_operators: ClassVar[dict[str, Callable[[int, int], int]]] = {
         "|": lambda a, b: a | b,
         "^": lambda a, b: a ^ b,
         "&": lambda a, b: a & b,
@@ -167,12 +166,12 @@ class Expression:
         "%": lambda a, b: a % b,
     }
 
-    unary_operators = {
+    unary_operators: ClassVar[dict[str, Callable[[int], int]]] = {
         "u": lambda a: -a,
         "~": lambda a: ~a,
     }
 
-    precedence_levels = {
+    precedence_levels: ClassVar[dict[str, int]] = {
         "|": 0,
         "^": 1,
         "&": 2,

{dissect_cstruct-4.3.dev1 → dissect_cstruct-4.4.dev1}/dissect/cstruct/parser.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import ast
 import re
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from dissect.cstruct import compiler
 from dissect.cstruct.exceptions import (
@@ -33,7 +33,7 @@ class Parser:
         Args:
             data: Data to parse definitions from, usually a string.
         """
-        raise NotImplementedError()
+        raise NotImplementedError
 
 
 class TokenParser(Parser):
@@ -119,10 +119,8 @@ class TokenParser(Parser):
                 val = val.strip()
                 if not key:
                     continue
-                if not val:
-                    val = nextval
-                else:
-                    val = Expression(self.cstruct, val).evaluate(values)
+
+                val = nextval if not val else Expression(self.cstruct, val).evaluate(values)
 
                 if enumtype == "flag":
                     high_bit = val.bit_length() - 1
@@ -243,7 +241,7 @@ class TokenParser(Parser):
         # Dirty trick because the regex expects a ; but we don't want it to be part of the value
         m = pattern.match(ltok.value + ";")
         d = ast.literal_eval(m.group(2))
-        self.cstruct.lookups[m.group(1)] = dict([(self.cstruct.consts[k], v) for k, v in d.items()])
+        self.cstruct.lookups[m.group(1)] = {self.cstruct.consts[k]: v for k, v in d.items()}
 
     def _parse_field(self, tokens: TokenConsumer) -> Field:
         type_ = None
@@ -279,10 +277,7 @@ class TokenParser(Parser):
 
         if count_expression is not None:
             # Poor mans multi-dimensional array by abusing the eager regex match of count
-            if "][" in count_expression:
-                counts = count_expression.split("][")
-            else:
-                counts = [count_expression]
+            counts = count_expression.split("][") if "][" in count_expression else [count_expression]
 
             for count in reversed(counts):
                 if count == "":
@@ -315,8 +310,7 @@ class TokenParser(Parser):
             if ntoken == self.TOK.NAME:
                 names.append(ntoken.value.strip())
             elif ntoken == self.TOK.DEFS:
-                for name in ntoken.value.strip().split(","):
-                    names.append(name.strip())
+                names.extend([name.strip() for name in ntoken.value.strip().split(",")])
 
         return names
 
@@ -333,8 +327,8 @@ class TokenParser(Parser):
             # it means we have captured a non-quoted (real) comment string.
             if comment := match.group(2):
                 return "\n" * comment.count("\n")  # so we will return empty to remove the comment
-            else:  # otherwise, we will return the 1st group
-                return match.group(1)  # captured quoted-string
+            # otherwise, we will return the 1st group
+            return match.group(1)  # captured quoted-string
 
         return regex.sub(_replacer, string)
 
@@ -429,10 +423,8 @@ class CStyleParser(Parser):
                     val = val.strip()
                     if not key:
                         continue
-                    if not val:
-                        val = nextval
-                    else:
-                        val = Expression(self.cstruct, val).evaluate()
+
+                    val = nextval if not val else Expression(self.cstruct, val).evaluate()
 
                     if enumtype == "flag":
                         high_bit = val.bit_length() - 1
@@ -535,7 +527,7 @@ class CStyleParser(Parser):
 
         for t in r:
             d = ast.literal_eval(t.group(2))
-            self.cstruct.lookups[t.group(1)] = dict([(self.cstruct.consts[k], v) for k, v in d.items()])
+            self.cstruct.lookups[t.group(1)] = {self.cstruct.consts[k]: v for k, v in d.items()}
 
     def parse(self, data: str) -> None:
         self._constants(data)
@@ -545,23 +537,23 @@ class CStyleParser(Parser):
 
 
 class Token:
-    __slots__ = ("token", "value", "match")
+    __slots__ = ("match", "token", "value")
 
     def __init__(self, token: str, value: str, match: re.Match):
         self.token = token
         self.value = value
         self.match = match
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         if isinstance(other, Token):
             other = other.token
 
         return self.token == other
 
-    def __ne__(self, other):
+    def __ne__(self, other: object) -> bool:
         return not self == other
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"<Token.{self.token} value={self.value!r}>"
 
 
@@ -571,7 +563,7 @@ class TokenCollection:
         self.lookup: dict[str, str] = {}
         self.patterns: dict[str, re.Pattern] = {}
 
-    def __getattr__(self, attr: str):
+    def __getattr__(self, attr: str) -> str | Any:
         try:
             return self.lookup[attr]
         except AttributeError:

{dissect_cstruct-4.3.dev1 → dissect_cstruct-4.4.dev1}/dissect/cstruct/types/base.py

@@ -59,7 +59,7 @@ class MetaType(type):
 
         return cls.size
 
-    def default(cls) -> BaseType:
+    def __default__(cls) -> BaseType:
         """Return the default value of this type."""
         return cls()
 
@@ -122,7 +122,7 @@ class MetaType(type):
             stream: The stream to read from.
             context: Optional reading context.
         """
-        raise NotImplementedError()
+        raise NotImplementedError
 
     def _read_array(cls, stream: BinaryIO, count: int, context: dict[str, Any] | None = None) -> list[BaseType]:
         """Internal function for reading array values.
@@ -136,11 +136,8 @@ class MetaType(type):
         """
         if count == EOF:
             result = []
-            while True:
-                try:
-                    result.append(cls._read(stream, context))
-                except EOFError:
-                    break
+            while not _is_eof(stream):
+                result.append(cls._read(stream, context))
             return result
 
         return [cls._read(stream, context) for _ in range(count)]
@@ -154,10 +151,10 @@ class MetaType(type):
             stream: The stream to read from.
             context: Optional reading context.
         """
-        raise NotImplementedError()
+        raise NotImplementedError
 
     def _write(cls, stream: BinaryIO, data: Any) -> int:
-        raise NotImplementedError()
+        raise NotImplementedError
 
     def _write_array(cls, stream: BinaryIO, array: list[BaseType]) -> int:
         """Internal function for writing arrays.
@@ -179,7 +176,7 @@ class MetaType(type):
             stream: The stream to read from.
             array: The array to write.
         """
-        return cls._write_array(stream, array + [cls.default()])
+        return cls._write_array(stream, [*array, cls.__default__()])
 
 
 class _overload:
@@ -200,8 +197,7 @@ class _overload:
     def __get__(self, instance: BaseType | None, owner: MetaType) -> Callable[[Any], bytes]:
         if instance is None:
             return functools.partial(self.func, owner)
-        else:
-            return functools.partial(self.func, instance.__class__, value=instance)
+        return functools.partial(self.func, instance.__class__, value=instance)
 
 
 class BaseType(metaclass=MetaType):
@@ -225,8 +221,10 @@ class ArrayMetaType(MetaType):
     num_entries: int | Expression | None
     null_terminated: bool
 
-    def default(cls) -> BaseType:
-        return type.__call__(cls, [cls.type.default()] * (cls.num_entries if isinstance(cls.num_entries, int) else 0))
+    def __default__(cls) -> BaseType:
+        return type.__call__(
+            cls, [cls.type.__default__()] * (cls.num_entries if isinstance(cls.num_entries, int) else 0)
+        )
 
     def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Array:
         if cls.null_terminated:
@@ -281,5 +279,17 @@ def _is_buffer_type(value: Any) -> bool:
     return isinstance(value, (bytes, memoryview, bytearray))
 
 
+def _is_eof(stream: BinaryIO) -> bool:
+    """Check if the stream has reached EOF."""
+    pos = stream.tell()
+    stream.read(1)
+
+    if stream.tell() == pos:
+        return True
+
+    stream.seek(pos)
+    return False
+
+
 # As mentioned in the BaseType class, we correctly set the type here
 MetaType.ArrayType = Array

{dissect_cstruct-4.3.dev1 → dissect_cstruct-4.4.dev1}/dissect/cstruct/types/char.py

@@ -25,7 +25,7 @@ class CharArray(bytes, BaseType, metaclass=ArrayMetaType):
         return stream.write(data)
 
     @classmethod
-    def default(cls) -> CharArray:
+    def __default__(cls) -> CharArray:
         return type.__call__(cls, b"\x00" * (0 if cls.dynamic or cls.null_terminated else cls.num_entries))
 
 
@@ -75,5 +75,5 @@ class Char(bytes, BaseType):
         return stream.write(data)
 
     @classmethod
-    def default(cls) -> Char:
+    def __default__(cls) -> Char:
         return type.__call__(cls, b"\x00")

{dissect_cstruct-4.3.dev1 → dissect_cstruct-4.4.dev1}/dissect/cstruct/types/enum.py

@@ -27,7 +27,7 @@ class EnumMetaType(EnumMeta, MetaType):
     ) -> EnumMetaType:
         if name is None:
             if value is None:
-                value = cls.type.default()
+                value = cls.type.__default__()
 
             if not isinstance(value, int):
                 # value is a parsable value
@@ -82,7 +82,7 @@ class EnumMetaType(EnumMeta, MetaType):
 
     def _write_0(cls, stream: BinaryIO, array: list[BaseType]) -> int:
         data = [entry.value if isinstance(entry, Enum) else entry for entry in array]
-        return cls._write_array(stream, data + [cls.type.default()])
+        return cls._write_array(stream, [*data, cls.type.__default__()])
 
 
 def _fix_alias_members(cls: type[Enum]) -> None:

{dissect_cstruct-4.3.dev1 → dissect_cstruct-4.4.dev1}/dissect/cstruct/types/leb128.py

@@ -28,9 +28,8 @@ class LEB128(int, BaseType):
             if (b & 0x80) == 0:
                 break
 
-        if cls.signed:
-            if b & 0x40 != 0:
-                result |= ~0 << shift
+        if cls.signed and b & 0x40 != 0:
+            result |= ~0 << shift
 
         return cls.__new__(cls, result)
 
@@ -60,7 +59,7 @@ class LEB128(int, BaseType):
 
             # function works similar for signed- and unsigned integers, except for the check when to stop
             # the encoding process.
-            if (cls.signed and (data == 0 and byte & 0x40 == 0) or (data == -1 and byte & 0x40 != 0)) or (
+            if ((cls.signed and (data == 0 and byte & 0x40 == 0)) or (data == -1 and byte & 0x40 != 0)) or (
                 not cls.signed and data == 0
             ):
                 result.append(byte)

{dissect_cstruct-4.3.dev1 → dissect_cstruct-4.4.dev1}/dissect/cstruct/types/pointer.py

@@ -16,7 +16,7 @@ class Pointer(int, BaseType):
     _context: dict[str, Any] | None
     _value: BaseType
 
-    def __new__(cls, value: int, stream: BinaryIO | None, context: dict[str, Any] | None = None) -> Pointer:
+    def __new__(cls, value: int, stream: BinaryIO | None, context: dict[str, Any] | None = None) -> Pointer:  # noqa: PYI034
         obj = super().__new__(cls, value)
         obj._stream = stream
         obj._context = context
@@ -66,8 +66,8 @@ class Pointer(int, BaseType):
         return type.__call__(self.__class__, int.__or__(self, other), self._stream, self._context)
 
     @classmethod
-    def default(cls) -> Pointer:
-        return cls.__new__(cls, cls.cs.pointer.default(), None, None)
+    def __default__(cls) -> Pointer:
+        return cls.__new__(cls, cls.cs.pointer.__default__(), None, None)
 
     @classmethod
     def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Pointer:
@@ -79,7 +79,7 @@ class Pointer(int, BaseType):
 
     def dereference(self) -> Any:
         if self == 0 or self._stream is None:
-            raise NullPointerDereference()
+            raise NullPointerDereference
 
         if self._value is None and not issubclass(self.type, Void):
             # Read current position of file read/write pointer

{dissect_cstruct-4.3.dev1 → dissect_cstruct-4.4.dev1}/dissect/cstruct/types/structure.py

@@ -7,8 +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 Any, BinaryIO, Callable, Iterator
+from typing import TYPE_CHECKING, Any, BinaryIO, Callable
 
 from dissect.cstruct.bitbuffer import BitBuffer
 from dissect.cstruct.types.base import (
@@ -20,11 +19,15 @@ from dissect.cstruct.types.base import (
 from dissect.cstruct.types.enum import EnumMetaType
 from dissect.cstruct.types.pointer import Pointer
 
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+    from types import FunctionType
+
 
 class Field:
     """Structure field."""
 
-    def __init__(self, name: str, type_: MetaType, bits: int = None, offset: int = None):
+    def __init__(self, name: str, type_: MetaType, bits: int | None = None, offset: int | None = None):
         self.name = name
         self.type = type_
         self.bits = bits
@@ -70,7 +73,7 @@ class StructureMetaType(MetaType):
         ):
             # Shortcut for single char/bytes type
             return type.__call__(cls, *args, **kwargs)
-        elif not args and not kwargs:
+        if not args and not kwargs:
             obj = type.__call__(cls)
             object.__setattr__(obj, "_values", {})
             object.__setattr__(obj, "_sizes", {})
@@ -259,8 +262,7 @@ class StructureMetaType(MetaType):
                 if field.name:
                     result[field.name] = value
                 continue
-            else:
-                bit_buffer.reset()
+            bit_buffer.reset()
 
             value = field_type._read(stream, result)
 
@@ -325,7 +327,7 @@ class StructureMetaType(MetaType):
 
             value = getattr(data, field.name, None)
             if value is None:
-                value = field_type.default()
+                value = field_type.__default__()
 
             if field.bits:
                 if isinstance(field_type, EnumMetaType):
@@ -540,7 +542,7 @@ class Union(Structure, metaclass=UnionMetaType):
 
     _buf: bytes
 
-    def __eq__(self, other: Any) -> bool:
+    def __eq__(self, other: object) -> bool:
         return self.__class__ is other.__class__ and bytes(self) == bytes(other)
 
     def __setattr__(self, attr: str, value: Any) -> None:
@@ -560,7 +562,7 @@ class Union(Structure, metaclass=UnionMetaType):
             buf.seek(field.offset)
 
         if (value := getattr(self, attr)) is None:
-            value = field.type.default()
+            value = field.type.__default__()
 
         field.type._write(buf, value)
 
@@ -774,7 +776,7 @@ def _generate_structure__init__(fields: list[Field]) -> FunctionType:
     template: FunctionType = _make_structure__init__(len(field_names))
     return type(template)(
         template.__code__.replace(
-            co_consts=(None, *[field.type.default() for field in fields]),
+            co_consts=(None, *[field.type.__default__() for field in fields]),
             co_names=(*field_names,),
             co_varnames=("self", *field_names),
         ),
@@ -794,7 +796,7 @@ def _generate_union__init__(fields: list[Field]) -> FunctionType:
     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-4.3.dev1 → dissect_cstruct-4.4.dev1}/dissect/cstruct/types/wchar.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import sys
-from typing import Any, BinaryIO
+from typing import Any, BinaryIO, ClassVar
 
 from dissect.cstruct.types.base import EOF, ArrayMetaType, BaseType
 
@@ -9,6 +9,8 @@ from dissect.cstruct.types.base import EOF, ArrayMetaType, BaseType
 class WcharArray(str, BaseType, metaclass=ArrayMetaType):
     """Wide-character array type for reading and writing UTF-16 strings."""
 
+    __slots__ = ()
+
     @classmethod
     def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> WcharArray:
         return type.__call__(cls, ArrayMetaType._read(cls, stream, context))
@@ -20,7 +22,7 @@ class WcharArray(str, BaseType, metaclass=ArrayMetaType):
         return stream.write(data.encode(Wchar.__encoding_map__[cls.cs.endian]))
 
     @classmethod
-    def default(cls) -> WcharArray:
+    def __default__(cls) -> WcharArray:
         return type.__call__(cls, "\x00" * (0 if cls.dynamic or cls.null_terminated else cls.num_entries))
 
 
@@ -29,7 +31,8 @@ class Wchar(str, BaseType):
 
     ArrayType = WcharArray
 
-    __encoding_map__ = {
+    __slots__ = ()
+    __encoding_map__: ClassVar[dict[str, str]] = {
         "@": f"utf-16-{sys.byteorder[0]}e",
         "=": f"utf-16-{sys.byteorder[0]}e",
         "<": "utf-16-le",
@@ -75,5 +78,5 @@ class Wchar(str, BaseType):
         return stream.write(data.encode(cls.__encoding_map__[cls.cs.endian]))
 
     @classmethod
-    def default(cls) -> Wchar:
+    def __default__(cls) -> Wchar:
         return type.__call__(cls, "\x00")