dissect.cstruct 4.6.dev3__tar.gz → 4.6.dev5__tar.gz

{dissect_cstruct-4.6.dev3 → dissect_cstruct-4.6.dev5}/CHANGELOG.md

@@ -11,6 +11,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 - Optimize storage of field sizes.
 - Rename `_sizes` property of `Structure` to `__sizes__`.
 - Rename `_values` property of `Structure` to `__values__`.
+- Added `load` argument to `cstruct` class, allowing direct initialization with a definition (i.e. `cstruct(cdef)` instead of `cstruct().load(cdef)`. Other arguments to `cstruct` are now keyword only.
 
 ## [4.5] - 20-05-2025
 

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

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

@@ -48,7 +48,7 @@ class cstruct:
     DEF_CSTYLE = 1
     DEF_LEGACY = 2
 
-    def __init__(self, endian: str = "<", pointer: str | None = None):
+    def __init__(self, load: str = "", *, endian: str = "<", pointer: str | None = None):
         self.endian = endian
 
         self.consts = {}
@@ -188,6 +188,9 @@ class cstruct:
         self.pointer: type[BaseType] = self.resolve(pointer)
         self._anonymous_count = 0
 
+        if load:
+            self.load(load)
+
     def __getattr__(self, attr: str) -> Any:
         try:
             return self.consts[attr]

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

@@ -828,13 +828,13 @@ def _generate_structure__init__(fields: list[Field]) -> FunctionType:
     Args:
         fields: List of field names.
     """
-    field_names = [field._name for field in fields]
+    mapping = _generate_co_mapping(fields)
 
-    template: FunctionType = _make_structure__init__(len(field_names))
+    template: FunctionType = _make_structure__init__(len(fields))
     return type(template)(
         template.__code__.replace(
-            co_names=tuple(chain.from_iterable(zip((f"__{name}_default__" for name in field_names), field_names))),
-            co_varnames=("self", *field_names),
+            co_names=_remap_co_values(template.__code__.co_names, mapping),
+            co_varnames=_remap_co_values(template.__code__.co_varnames, mapping),
         ),
         template.__globals__ | {f"__{field._name}_default__": field.type.__default__() for field in fields},
         argdefs=template.__defaults__,
@@ -847,20 +847,50 @@ def _generate_union__init__(fields: list[Field]) -> FunctionType:
     Args:
         fields: List of field names.
     """
-    field_names = [field._name for field in fields]
+    mapping = _generate_co_mapping(fields)
 
-    template: FunctionType = _make_union__init__(len(field_names))
+    template: FunctionType = _make_union__init__(len(fields))
     return type(template)(
         template.__code__.replace(
-            co_consts=(None, *field_names),
-            co_names=("object", "__setattr__", *(f"__{name}_default__" for name in field_names)),
-            co_varnames=("self", *field_names),
+            co_consts=_remap_co_values(template.__code__.co_consts, mapping),
+            co_names=_remap_co_values(template.__code__.co_names, mapping),
+            co_varnames=_remap_co_values(template.__code__.co_varnames, mapping),
         ),
         template.__globals__ | {f"__{field._name}_default__": field.type.__default__() for field in fields},
         argdefs=template.__defaults__,
     )
 
 
+def _generate_co_mapping(fields: list[Field]) -> dict[str, str]:
+    """Generates a mapping of generated code object names to field names.
+
+    The generated code uses names like ``_0``, ``_1``, etc. for fields, and ``_0_default``, ``_1_default``, etc.
+    for default initializer values. Return a mapping of these names to the actual field names.
+
+    Args:
+        fields: List of field names.
+    """
+    return {
+        key: value
+        for i, field in enumerate(fields)
+        for key, value in [(f"_{i}", field._name), (f"_{i}_default", f"__{field._name}_default__")]
+    }
+
+
+def _remap_co_values(value: tuple[Any, ...], mapping: dict[str, str]) -> tuple[Any, ...]:
+    """Remaps code object values using a mapping.
+
+    This is used to replace generated code object names with actual field names.
+
+    Args:
+        value: The original code object values.
+        mapping: A mapping of generated code object names to field names.
+    """
+    # Only attempt to remap if the value is a string, otherwise return it as is
+    # This is to avoid issues with trying to remap non-hashable types, and we only need to replace strings anyway
+    return tuple(mapping.get(v, v) if isinstance(v, str) else v for v in value)
+
+
 def _generate__eq__(fields: list[str]) -> FunctionType:
     """Generates an ``__eq__`` method for a class with the specified fields.
 

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

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

@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING, BinaryIO
 
 import pytest
 
+from dissect.cstruct.cstruct import cstruct
 from dissect.cstruct.exceptions import ArraySizeError, ParserError, ResolveError
 from dissect.cstruct.types import BaseType
 
@@ -14,8 +15,6 @@ from .utils import verify_compiled
 if TYPE_CHECKING:
     from pathlib import Path
 
-    from dissect.cstruct.cstruct import cstruct
-
 
 def test_duplicate_type(cs: cstruct, compiled: bool) -> None:
     cdef = """
@@ -41,6 +40,51 @@ def test_load_file(cs: cstruct, compiled: bool, tmp_path: Path) -> None:
     assert "test" in cs.typedefs
 
 
+def test_load_init() -> None:
+    cdef = """
+    struct test {
+        DWORD   a;
+        QWORD   b;
+    };
+    """
+    # load with first positional argument
+    cs = cstruct(cdef)
+    assert "test" in cs.typedefs
+    assert cs.endian == "<"
+
+    # load from keyword argument and big endian
+    cs = cstruct(load=cdef, endian=">")
+    assert "test" in cs.typedefs
+    a = cs.test(a=0xBADC0DE, b=0xACCE55ED)
+    assert len(bytes(a)) == 12
+    assert bytes(a) == a.dumps()
+    assert bytes(a) == b"\x0b\xad\xc0\xde\x00\x00\x00\x00\xac\xce\x55\xed"
+
+    # load using positional argument and little endian
+    cs = cstruct(cdef, endian="<")
+    assert "test" in cs.typedefs
+    a = cs.test(a=0xBADC0DE, b=0xACCE55ED)
+    assert len(bytes(a)) == 12
+    assert bytes(a) == a.dumps()
+    assert bytes(a) == b"\xde\xc0\xad\x0b\xed\x55\xce\xac\x00\x00\x00\x00"
+
+
+def test_load_init_kwargs_only() -> None:
+    cdef = """
+    struct test {
+        uint32  a;
+    };
+    """
+
+    # kwargs only check
+    with pytest.raises(TypeError, match="takes from .* positional arguments but .* were given"):
+        cs = cstruct(cdef, ">")
+
+    cs = cstruct(cdef, endian=">")
+    assert "test" in cs.typedefs
+    assert cs.endian == ">"
+
+
 def test_read_type_name(cs: cstruct) -> None:
     assert cs.read("uint32", b"\x01\x00\x00\x00") == 1