dissect.cstruct 4.5.dev3__tar.gz → 4.5.dev5__tar.gz

{dissect_cstruct-4.5.dev3 → dissect_cstruct-4.5.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dissect.cstruct
-Version: 4.5.dev3
+Version: 4.5.dev5
 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.5.dev3 → dissect_cstruct-4.5.dev5}/dissect/cstruct/compiler.py

@@ -21,6 +21,7 @@ from dissect.cstruct.types import (
     Structure,
     Union,
     Void,
+    VoidArray,
     Wchar,
     WcharArray,
 )
@@ -48,6 +49,7 @@ SUPPORTED_TYPES = (
     Void,
     Wchar,
     WcharArray,
+    VoidArray,
 )
 
 log = logging.getLogger(__name__)
@@ -365,7 +367,7 @@ def _generate_struct_info(cs: cstruct, fields: list[Field], align: bool = False)
         read_type = _get_read_type(cs, field.type)
 
         # Drop voids
-        if issubclass(read_type, Void):
+        if issubclass(read_type, (Void, VoidArray)):
             continue
 
         # Array of more complex types are handled elsewhere

{dissect_cstruct-4.5.dev3 → dissect_cstruct-4.5.dev5}/dissect/cstruct/types/__init__.py

@@ -7,7 +7,7 @@ from dissect.cstruct.types.leb128 import LEB128
 from dissect.cstruct.types.packed import Packed
 from dissect.cstruct.types.pointer import Pointer
 from dissect.cstruct.types.structure import Field, Structure, Union
-from dissect.cstruct.types.void import Void
+from dissect.cstruct.types.void import Void, VoidArray
 from dissect.cstruct.types.wchar import Wchar, WcharArray
 
 __all__ = [
@@ -27,6 +27,7 @@ __all__ = [
     "Structure",
     "Union",
     "Void",
+    "VoidArray",
     "Wchar",
     "WcharArray",
 ]

{dissect_cstruct-4.5.dev3 → dissect_cstruct-4.5.dev5}/dissect/cstruct/types/base.py

@@ -54,6 +54,10 @@ class MetaType(type):
         """Create a new array with the given number of entries."""
         return cls.cs._make_array(cls, num_entries)
 
+    def __bool__(cls) -> bool:
+        """Type class is always truthy."""
+        return True
+
     def __len__(cls) -> int:
         """Return the byte size of the type."""
         # Python 3.9 compat thing for bound type vars

{dissect_cstruct-4.5.dev3 → dissect_cstruct-4.5.dev5}/dissect/cstruct/types/enum.py

@@ -77,7 +77,7 @@ class EnumMetaType(EnumMeta, MetaType):
     __len__ = MetaType.__len__
 
     def __contains__(cls, value: Any) -> bool:
-        # We used to let stdlib enum handle `__containts``` but this commit is incompatible with our API:
+        # We used to let stdlib enum handle `__contains__``` but this commit is incompatible with our API:
         # https://github.com/python/cpython/commit/8a9aee71268c77867d3cc96d43cbbdcbe8c0e1e8
         if isinstance(value, cls):
             return True

{dissect_cstruct-4.5.dev3 → dissect_cstruct-4.5.dev5}/dissect/cstruct/types/structure.py

@@ -673,7 +673,9 @@ def _make_structure__init__(fields: list[str]) -> str:
         fields: List of field names.
     """
     field_args = ", ".join(f"{field} = None" for field in fields)
-    field_init = "\n".join(f" self.{name} = {name} if {name} is not None else {i}" for i, name in enumerate(fields))
+    field_init = "\n".join(
+        f" self.{name} = {name} if {name} is not None else _{i}_default" for i, name in enumerate(fields)
+    )
 
     code = f"def __init__(self{', ' + field_args or ''}):\n"
     return code + (field_init or " pass")
@@ -688,7 +690,8 @@ def _make_union__init__(fields: list[str]) -> str:
     """
     field_args = ", ".join(f"{field} = None" for field in fields)
     field_init = "\n".join(
-        f" object.__setattr__(self, '{name}', {name} if {name} is not None else {i})" for i, name in enumerate(fields)
+        f" object.__setattr__(self, '{name}', {name} if {name} is not None else _{i}_default)"
+        for i, name in enumerate(fields)
     )
 
     code = f"def __init__(self{', ' + field_args or ''}):\n"
@@ -780,11 +783,10 @@ 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_names=(*field_names,),
+            co_names=tuple(chain.from_iterable(zip((f"__{name}_default__" for name in field_names), field_names))),
             co_varnames=("self", *field_names),
         ),
-        template.__globals__,
+        template.__globals__ | {f"__{field._name}_default__": field.type.__default__() for field in fields},
         argdefs=template.__defaults__,
     )
 
@@ -800,13 +802,11 @@ 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, *field_names),
+            co_names=("object", "__setattr__", *(f"__{name}_default__" for name in field_names)),
             co_varnames=("self", *field_names),
         ),
-        template.__globals__,
+        template.__globals__ | {f"__{field._name}_default__": field.type.__default__() for field in fields},
         argdefs=template.__defaults__,
     )
 

dissect_cstruct-4.5.dev5/dissect/cstruct/types/void.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, BinaryIO
+
+from dissect.cstruct.types.base import BaseArray, BaseType
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+
+class VoidArray(list, BaseArray):
+    """Array type representing void elements, primarily used for no-op reading and writing operations."""
+
+    @classmethod
+    def __default__(cls) -> Self:
+        return cls()
+
+    @classmethod
+    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Self:
+        return cls()
+
+    @classmethod
+    def _write(cls, stream: BinaryIO, data: bytes) -> int:
+        return 0
+
+
+class Void(BaseType):
+    """Void type."""
+
+    ArrayType = VoidArray
+
+    def __bool__(self) -> bool:
+        return False
+
+    def __eq__(self, value: object) -> bool:
+        return isinstance(value, Void)
+
+    @classmethod
+    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Self:
+        return cls.__new__(cls)
+
+    @classmethod
+    def _write(cls, stream: BinaryIO, data: Void) -> int:
+        return 0

{dissect_cstruct-4.5.dev3 → dissect_cstruct-4.5.dev5}/dissect.cstruct.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dissect.cstruct
-Version: 4.5.dev3
+Version: 4.5.dev5
 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.5.dev3 → dissect_cstruct-4.5.dev5}/tests/test_types_base.py

@@ -137,3 +137,12 @@ def test_custom_array_type(cs: cstruct, compiled: bool) -> None:
     assert isinstance(result.b, CustomType)
     assert result.a.value == b"ASDF"
     assert result.b.value == b"asdf"
+
+
+def test_truthy_type(cs: cstruct) -> None:
+    static_type = cs.uint32
+    dynamic_type = cs.uint32[None]
+
+    assert static_type
+    # Should not raise a TypeError: Dynamic size
+    assert dynamic_type

{dissect_cstruct-4.5.dev3 → dissect_cstruct-4.5.dev5}/tests/test_types_structure.py

@@ -750,11 +750,11 @@ def test_codegen_make_init() -> None:
     result = _make__init__([f"_{n}" for n in range(5)])
     expected = """
     def __init__(self, _0 = None, _1 = None, _2 = None, _3 = None, _4 = None):
-     self._0 = _0 if _0 is not None else 0
-     self._1 = _1 if _1 is not None else 1
-     self._2 = _2 if _2 is not None else 2
-     self._3 = _3 if _3 is not None else 3
-     self._4 = _4 if _4 is not None else 4
+     self._0 = _0 if _0 is not None else _0_default
+     self._1 = _1 if _1 is not None else _1_default
+     self._2 = _2 if _2 is not None else _2_default
+     self._3 = _3 if _3 is not None else _3_default
+     self._4 = _4 if _4 is not None else _4_default
     """
     assert result == dedent(expected[1:].rstrip())
 
@@ -765,3 +765,14 @@ def test_codegen_make_init() -> None:
     cached = structure._make_structure__init__(5)
     assert structure._make_structure__init__.cache_info() == (1, 1, 128, 1)
     assert result is cached
+
+
+def test_codegen_hashable(cs: cstruct) -> None:
+    hashable_fields = [Field("a", cs.uint8), Field("b", cs.uint8)]
+    unhashable_fields = [Field("a", cs.uint8[2]), Field("b", cs.uint8)]
+
+    with pytest.raises(TypeError, match="unhashable type: 'uint8\\[2\\]'"):
+        hash(unhashable_fields[0].type.__default__())
+
+    assert hash(structure._generate_structure__init__(hashable_fields).__code__)
+    assert hash(structure._generate_structure__init__(unhashable_fields).__code__)

{dissect_cstruct-4.5.dev3 → dissect_cstruct-4.5.dev5}/tests/test_types_union.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING
 
 import pytest
 
+from dissect.cstruct.types import structure
 from dissect.cstruct.types.base import Array, BaseType
 from dissect.cstruct.types.structure import Field, Union, UnionProxy
 
@@ -535,3 +536,14 @@ def test_union_partial_initialization_dynamic(cs: cstruct) -> None:
 
     with pytest.raises(NotImplementedError, match="Initializing a dynamic union is not yet supported"):
         cs.test(x=1)
+
+
+def test_codegen_hashable(cs: cstruct) -> None:
+    hashable_fields = [Field("a", cs.uint8), Field("b", cs.uint8)]
+    unhashable_fields = [Field("a", cs.uint8[2]), Field("b", cs.uint8)]
+
+    with pytest.raises(TypeError, match="unhashable type: 'uint8\\[2\\]'"):
+        hash(unhashable_fields[0].type.__default__())
+
+    assert hash(structure._generate_union__init__(hashable_fields).__code__)
+    assert hash(structure._generate_union__init__(unhashable_fields).__code__)

{dissect_cstruct-4.5.dev3 → dissect_cstruct-4.5.dev5}/tests/test_types_void.py

@@ -10,7 +10,9 @@ if TYPE_CHECKING:
 
 
 def test_void_read(cs: cstruct) -> None:
-    assert not cs.void
+    # The type itself is truthy, but an instance is not
+    assert cs.void
+    assert not cs.void()
 
     stream = io.BytesIO(b"AAAA")
     assert not cs.void(stream)
@@ -23,11 +25,11 @@ def test_void_write(cs: cstruct) -> None:
 
 
 def test_void_array_read(cs: cstruct) -> None:
-    assert not cs.void[4]
+    assert not cs.void[4]()
 
     stream = io.BytesIO(b"AAAA")
-    assert not any(cs.void[4](stream))
-    assert not any(cs.void[None](stream))
+    assert not cs.void[4](stream)
+    assert not cs.void[None](stream)
     assert stream.tell() == 0
 
 
@@ -41,7 +43,7 @@ def test_void_default(cs: cstruct) -> None:
     assert not cs.void()
     assert not cs.void.__default__()
 
-    assert cs.void[1].__default__() == [cs.void()]
+    assert cs.void[1].__default__() == []
     assert cs.void[None].__default__() == []
 
 
@@ -61,8 +63,8 @@ def test_void_struct(cs: cstruct, compiled: bool) -> None:
 
     obj = cs.test(stream)
     assert not obj.a
-    assert not any(obj.b)
-    assert not any(obj.c)
+    assert not obj.b
+    assert not obj.c
 
     assert stream.tell() == 0
 

dissect_cstruct-4.5.dev3/dissect/cstruct/types/void.py

@@ -1,27 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, BinaryIO
-
-from dissect.cstruct.types.base import BaseType
-
-
-class Void(BaseType):
-    """Void type."""
-
-    def __bool__(self) -> bool:
-        return False
-
-    def __eq__(self, value: object) -> bool:
-        return isinstance(value, Void)
-
-    @classmethod
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Void:
-        return cls.__new__(cls)
-
-    @classmethod
-    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Void:
-        return [cls.__new__(cls)]
-
-    @classmethod
-    def _write(cls, stream: BinaryIO, data: Void) -> int:
-        return 0