sltcodec 1.2.1__tar.gz → 1.3.0__tar.gz

{sltcodec-1.2.1 → sltcodec-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sltcodec
-Version: 1.2.1
+Version: 1.3.0
 Summary: Decode and encode bytearrays according to struct layout definitions using sltcore.
 Project-URL: Homepage, https://github.com/fangface-hub/StructLayoutToolkitCodec
 Project-URL: Documentation, https://readthedocs.org
@@ -199,10 +199,10 @@ print(encoded_int, decoded_int)
 print(encoded_float, decoded_float)
 ```
 
-## Saving And Loading StructDef Dictionaries
+## Saving And Loading Type Dictionaries
 
-You can persist reusable structure definitions by name with
-`save_struct_def_dict` / `load_struct_def_dict`.
+You can persist reusable structure and enum definitions together via
+`TypeDict` with `save_type_dict` / `load_type_dict`.
 
 `InfoSize` values in `offset` and `size` are saved as typed dictionaries in
 JSON. Expression-based offsets and sizes remain strings and are resolved when
@@ -212,25 +212,31 @@ the definition is used.
 from pathlib import Path
 
 from sltcore import InfoSize
-from sltcodec import FieldDef, StructDef, load_struct_def_dict, save_struct_def_dict
-
-struct_defs = {
-    "Header": StructDef(
-        name="Header",
-        description="Simple header",
-        fields=[
-            FieldDef(name="kind", offset=InfoSize(0, 0), size=InfoSize(1, 0), type="unsigned int"),
-            FieldDef(name="flags", offset=InfoSize(1, 0), size=InfoSize(1, 0), type="unsigned int"),
-        ],
-    )
-}
+from sltcodec import EnumDef, FieldDef, StructDef, TypeDict, load_type_dict, save_type_dict
+
+type_dict = TypeDict(
+    struct_dict={
+        "Header": StructDef(
+            name="Header",
+            description="Simple header",
+            fields=[
+                FieldDef(name="kind", offset=InfoSize(0, 0), size=InfoSize(1, 0), type="unsigned int"),
+                FieldDef(name="flags", offset=InfoSize(1, 0), size=InfoSize(1, 0), type="unsigned int"),
+            ],
+        )
+    },
+    enum_dict={
+        "Status": EnumDef(name="Status", values={"OK": 0, "NG": 1}),
+    }
+)
 
 path = Path("struct_defs.json")
-save_struct_def_dict(path, struct_defs)
-loaded = load_struct_def_dict(path)
+save_type_dict(path, type_dict)
+loaded = load_type_dict(path)
 
-print(loaded["Header"].name)
-print(loaded["Header"].description)
+print(loaded.struct_dict["Header"].name)
+print(loaded.struct_dict["Header"].description)
+print(loaded.enum_dict["Status"].values["NG"])
 ```
 
 Example output:
@@ -238,31 +244,42 @@ Example output:
 ```python
 Header
 Simple header
+1
 ```
 
 ## Enum Definitions
 
 `FieldDef.enum_def_name` holds only the name of an `EnumDef`, not the definition
-itself. Pass the actual definitions via an `enum_def_dict` (mapping name to
-`EnumDef`) to `decode` / `encode` so the matching `EnumDef` can be resolved and
-attached as `FieldInstance.enum_item`.
+itself. In practice, `TypeDict` is most useful when you pass both
+`type_dict.struct_dict` and `type_dict.enum_dict` together: one resolves named
+layout types and the other resolves enum labels. The example below uses both in
+one decode flow.
 
 ```python
 from sltcore import InfoSize
-from sltcodec import EnumDef, FieldDef, decode
+from sltcodec import EnumDef, EnumDict, FieldDef, StructDef, StructDict, TypeDict, decode
+
+enum_dict = EnumDict({"Status": EnumDef(name="Status", values={"OK": 0, "NG": 1})})
+
+packet_struct = StructDef(
+    name="Packet",
+    fields=[
+        FieldDef(name="status",
+                 offset=InfoSize(0, 0),
+                 size=InfoSize(1, 0),
+                 type="unsigned int",
+                 enum_def_name="Status"),
+    ],
+)
 
-status_enum = EnumDef(name="Status", values={"OK": 0, "NG": 1})
+struct_dict = StructDict({"Packet": packet_struct})
 
-struct_def = [
-    FieldDef(name="status",
-             offset=InfoSize(0, 0),
-             size=InfoSize(1, 0),
-             type="unsigned int",
-             enum_def_name="Status"),
-]
+type_dict = TypeDict(struct_dict=struct_dict.items_dict(),
+                     enum_dict=enum_dict.items_dict())
 
-decoded = decode(struct_def, bytearray(b"\x01"),
-                 enum_def_dict={"Status": status_enum})
+decoded = decode(type_dict.struct_dict["Packet"],
+                 bytearray(b"\x01"),
+                 type_dict=type_dict)
 
 print(decoded.field_instances[0].value)
 print(decoded.field_instances[0].enum_item)
@@ -275,8 +292,8 @@ Output:
 ('NG', 1)
 ```
 
-You can also persist enum definitions by name with
-`save_enum_def_dict` / `load_enum_def_dict`, mirroring `StructDef` dictionaries.
+You can also persist enum definitions by name through `TypeDict` using
+`save_type_dict` / `load_type_dict`.
 
 ## Development
 

{sltcodec-1.2.1 → sltcodec-1.3.0}/README.md

@@ -182,10 +182,10 @@ print(encoded_int, decoded_int)
 print(encoded_float, decoded_float)
 ```
 
-## Saving And Loading StructDef Dictionaries
+## Saving And Loading Type Dictionaries
 
-You can persist reusable structure definitions by name with
-`save_struct_def_dict` / `load_struct_def_dict`.
+You can persist reusable structure and enum definitions together via
+`TypeDict` with `save_type_dict` / `load_type_dict`.
 
 `InfoSize` values in `offset` and `size` are saved as typed dictionaries in
 JSON. Expression-based offsets and sizes remain strings and are resolved when
@@ -195,25 +195,31 @@ the definition is used.
 from pathlib import Path
 
 from sltcore import InfoSize
-from sltcodec import FieldDef, StructDef, load_struct_def_dict, save_struct_def_dict
-
-struct_defs = {
-    "Header": StructDef(
-        name="Header",
-        description="Simple header",
-        fields=[
-            FieldDef(name="kind", offset=InfoSize(0, 0), size=InfoSize(1, 0), type="unsigned int"),
-            FieldDef(name="flags", offset=InfoSize(1, 0), size=InfoSize(1, 0), type="unsigned int"),
-        ],
-    )
-}
+from sltcodec import EnumDef, FieldDef, StructDef, TypeDict, load_type_dict, save_type_dict
+
+type_dict = TypeDict(
+    struct_dict={
+        "Header": StructDef(
+            name="Header",
+            description="Simple header",
+            fields=[
+                FieldDef(name="kind", offset=InfoSize(0, 0), size=InfoSize(1, 0), type="unsigned int"),
+                FieldDef(name="flags", offset=InfoSize(1, 0), size=InfoSize(1, 0), type="unsigned int"),
+            ],
+        )
+    },
+    enum_dict={
+        "Status": EnumDef(name="Status", values={"OK": 0, "NG": 1}),
+    }
+)
 
 path = Path("struct_defs.json")
-save_struct_def_dict(path, struct_defs)
-loaded = load_struct_def_dict(path)
+save_type_dict(path, type_dict)
+loaded = load_type_dict(path)
 
-print(loaded["Header"].name)
-print(loaded["Header"].description)
+print(loaded.struct_dict["Header"].name)
+print(loaded.struct_dict["Header"].description)
+print(loaded.enum_dict["Status"].values["NG"])
 ```
 
 Example output:
@@ -221,31 +227,42 @@ Example output:
 ```python
 Header
 Simple header
+1
 ```
 
 ## Enum Definitions
 
 `FieldDef.enum_def_name` holds only the name of an `EnumDef`, not the definition
-itself. Pass the actual definitions via an `enum_def_dict` (mapping name to
-`EnumDef`) to `decode` / `encode` so the matching `EnumDef` can be resolved and
-attached as `FieldInstance.enum_item`.
+itself. In practice, `TypeDict` is most useful when you pass both
+`type_dict.struct_dict` and `type_dict.enum_dict` together: one resolves named
+layout types and the other resolves enum labels. The example below uses both in
+one decode flow.
 
 ```python
 from sltcore import InfoSize
-from sltcodec import EnumDef, FieldDef, decode
+from sltcodec import EnumDef, EnumDict, FieldDef, StructDef, StructDict, TypeDict, decode
+
+enum_dict = EnumDict({"Status": EnumDef(name="Status", values={"OK": 0, "NG": 1})})
+
+packet_struct = StructDef(
+    name="Packet",
+    fields=[
+        FieldDef(name="status",
+                 offset=InfoSize(0, 0),
+                 size=InfoSize(1, 0),
+                 type="unsigned int",
+                 enum_def_name="Status"),
+    ],
+)
 
-status_enum = EnumDef(name="Status", values={"OK": 0, "NG": 1})
+struct_dict = StructDict({"Packet": packet_struct})
 
-struct_def = [
-    FieldDef(name="status",
-             offset=InfoSize(0, 0),
-             size=InfoSize(1, 0),
-             type="unsigned int",
-             enum_def_name="Status"),
-]
+type_dict = TypeDict(struct_dict=struct_dict.items_dict(),
+                     enum_dict=enum_dict.items_dict())
 
-decoded = decode(struct_def, bytearray(b"\x01"),
-                 enum_def_dict={"Status": status_enum})
+decoded = decode(type_dict.struct_dict["Packet"],
+                 bytearray(b"\x01"),
+                 type_dict=type_dict)
 
 print(decoded.field_instances[0].value)
 print(decoded.field_instances[0].enum_item)
@@ -258,8 +275,8 @@ Output:
 ('NG', 1)
 ```
 
-You can also persist enum definitions by name with
-`save_enum_def_dict` / `load_enum_def_dict`, mirroring `StructDef` dictionaries.
+You can also persist enum definitions by name through `TypeDict` using
+`save_type_dict` / `load_type_dict`.
 
 ## Development
 

{sltcodec-1.2.1 → sltcodec-1.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sltcodec"
-version = "1.2.1"
+version = "1.3.0"
 description = "Decode and encode bytearrays according to struct layout definitions using sltcore."
 readme = "README.md"
 requires-python = ">=3.12"

sltcodec-1.3.0/src/sltcodec/__init__.py

@@ -0,0 +1,21 @@
+from .codec import (PRIMITIVE_TYPES, decode, encode, encode_field,
+                    load_type_dict, save_type_dict)
+from .types import (EnumDef, EnumDict, FieldDef, FieldInstance, StructDef,
+                    StructDict, StructInstance, TypeDict)
+
+__all__ = [
+    "PRIMITIVE_TYPES",
+    "EnumDef",
+    "EnumDict",
+    "FieldDef",
+    "FieldInstance",
+    "StructDef",
+    "StructDict",
+    "StructInstance",
+    "TypeDict",
+    "decode",
+    "encode",
+    "encode_field",
+    "load_type_dict",
+    "save_type_dict",
+]

{sltcodec-1.2.1 → sltcodec-1.3.0}/src/sltcodec/codec.py

@@ -8,7 +8,8 @@ from typing import Any
 from sltcalc import SltEval
 from sltcore import Info, InfoSize, bits_get, bits_set
 
-from .types import EnumDef, FieldDef, FieldInstance, StructDef, StructInstance
+from .types import (EnumDef, FieldDef, FieldInstance, StructDef, StructInstance,
+                    TypeDict)
 
 PRIMITIVE_TYPES = {
     "bool",
@@ -46,44 +47,78 @@ def _validate_struct_instance(struct_instance: StructInstance) -> None:
                 f"{type(field_instance).__name__}")
 
 
-def save_struct_def_dict(path: str | Path,
-                         struct_def_dict: dict[str, StructDef]) -> None:
-    """Save a structure definition dictionary to a JSON file."""
+def save_type_dict(path: str | Path, type_dict: TypeDict) -> None:
+    """Save TypeDict to a JSON file."""
     payload = {
-        name: struct_def.to_dict()
-        for name, struct_def in struct_def_dict.items()
+        "struct_dict": {
+            name: struct_def.to_dict()
+            for name, struct_def in type_dict.struct_dict.items()
+        },
+        "enum_dict": {
+            name: enum_def.to_dict()
+            for name, enum_def in type_dict.enum_dict.items()
+        },
     }
     Path(path).write_text(json.dumps(payload, ensure_ascii=False, indent=2),
                           encoding="utf-8")
 
 
+def load_type_dict(path: str | Path) -> TypeDict:
+    """Load TypeDict from a JSON file."""
+    data = json.loads(Path(path).read_text(encoding="utf-8"))
+
+    struct_payload = data.get("struct_dict")
+    enum_payload = data.get("enum_dict")
+
+    if isinstance(struct_payload, dict) and isinstance(enum_payload, dict):
+        return TypeDict(
+            struct_dict={
+                name: StructDef.from_dict(struct_def_data)
+                for name, struct_def_data in struct_payload.items()
+            },
+            enum_dict={
+                name: EnumDef.from_dict(enum_def_data)
+                for name, enum_def_data in enum_payload.items()
+            },
+        )
+
+    # Backward compatibility: old files that stored only struct or enum maps.
+    legacy_entries: dict[str, Any] = data if isinstance(data, dict) else {}
+    if any(
+            isinstance(item, dict) and "fields" in item
+            for item in legacy_entries.values()):
+        return TypeDict(
+            struct_dict={
+                name: StructDef.from_dict(struct_def_data)
+                for name, struct_def_data in legacy_entries.items()
+            })
+    return TypeDict(
+        enum_dict={
+            name: EnumDef.from_dict(enum_def_data)
+            for name, enum_def_data in legacy_entries.items()
+        })
+
+
+def save_struct_def_dict(path: str | Path,
+                         struct_def_dict: dict[str, StructDef]) -> None:
+    """Save a structure definition dictionary to a JSON file."""
+    save_type_dict(path, TypeDict(struct_dict=struct_def_dict))
+
+
 def load_struct_def_dict(path: str | Path) -> dict[str, StructDef]:
     """Load a structure definition dictionary from a JSON file."""
-    data = json.loads(Path(path).read_text(encoding="utf-8"))
-    return {
-        name: StructDef.from_dict(field_def_data)
-        for name, field_def_data in data.items()
-    }
+    return load_type_dict(path).struct_dict.items_dict()
 
 
 def save_enum_def_dict(path: str | Path, enum_def_dict: dict[str,
                                                              EnumDef]) -> None:
     """Save an enum definition dictionary to a JSON file."""
-    payload = {
-        name: enum_def.to_dict()
-        for name, enum_def in enum_def_dict.items()
-    }
-    Path(path).write_text(json.dumps(payload, ensure_ascii=False, indent=2),
-                          encoding="utf-8")
+    save_type_dict(path, TypeDict(enum_dict=enum_def_dict))
 
 
 def load_enum_def_dict(path: str | Path) -> dict[str, EnumDef]:
     """Load an enum definition dictionary from a JSON file."""
-    data = json.loads(Path(path).read_text(encoding="utf-8"))
-    return {
-        name: EnumDef.from_dict(enum_def_data)
-        for name, enum_def_data in data.items()
-    }
+    return load_type_dict(path).enum_dict.items_dict()
 
 
 def _resolve_info_size(value: InfoSize | str, env: dict[str, Any]) -> InfoSize:
@@ -144,7 +179,7 @@ def _validate_padding_alignment_bits(padding_alignment_bits: int) -> None:
 
 
 def _resolve_field_type(field_type: str | StructDef,
-                        struct_def_dict: dict[str, StructDef] | None = None,
+                        type_dict: TypeDict | None = None,
                         env: dict[str, Any] | None = None) -> str | StructDef:
     """Resolve a field type that can be primitive, named, or nested."""
     if isinstance(field_type, StructDef):
@@ -152,7 +187,7 @@ def _resolve_field_type(field_type: str | StructDef,
     if field_type in _PRIMITIVE_TYPES:
         return field_type
 
-    resolved_struct_def = _get_struct_def(field_type, struct_def_dict, env)
+    resolved_struct_def = _get_struct_def(field_type, type_dict, env)
     if isinstance(resolved_struct_def, StructDef):
         return resolved_struct_def
     if (isinstance(resolved_struct_def, str)
@@ -188,8 +223,7 @@ def _prepare_field_info(
     field_def: FieldDef,
     value: Any,
     env: dict[str, Any],
-    struct_def_dict: dict[str, StructDef] | None = None,
-    enum_def_dict: dict[str, EnumDef] | None = None,
+    type_dict: TypeDict | None = None,
     padding_alignment_bits: int = _DEFAULT_PADDING_ALIGNMENT_BITS,
 ) -> tuple[InfoSize, InfoSize, Info] | None:
     """Resolve a field definition into an offset, size, and info payload."""
@@ -198,7 +232,7 @@ def _prepare_field_info(
     if size.byte == 0 and size.bit == 0:
         return None
 
-    resolved_type = _resolve_field_type(field_def.type, struct_def_dict, env)
+    resolved_type = _resolve_field_type(field_def.type, type_dict, env)
     if isinstance(resolved_type, StructDef):
         if not isinstance(value, StructInstance):
             raise TypeError(
@@ -206,8 +240,7 @@ def _prepare_field_info(
                 "values")
         nested_bytes = encode(value,
                               bytearray(),
-                              struct_def_dict,
-                              enum_def_dict,
+                              type_dict,
                               padding_alignment_bits=padding_alignment_bits)
         info = Info.from_bytes(bytes(nested_bytes), size, scale=field_def.scale)
     else:
@@ -233,16 +266,15 @@ def encode_field(
     value: Any,
     buf: bytearray,
     env: dict[str, Any] | None = None,
-    struct_def_dict: dict[str, StructDef] | None = None,
-    enum_def_dict: dict[str, EnumDef] | None = None,
+    type_dict: TypeDict | None = None,
     padding_alignment_bits: int = _DEFAULT_PADDING_ALIGNMENT_BITS,
 ) -> None:
     """Encode a single field into a bytearray."""
     if env is None:
         env = {}
 
-    prepared = _prepare_field_info(field_def, value, env, struct_def_dict,
-                                   enum_def_dict, padding_alignment_bits)
+    prepared = _prepare_field_info(field_def, value, env, type_dict,
+                                   padding_alignment_bits)
     if prepared is None:
         return
 
@@ -259,8 +291,7 @@ def encode_field(
 def encode(
     struct_instance: StructInstance,
     buf: bytearray,
-    struct_def_dict: dict[str, StructDef] | None = None,
-    enum_def_dict: dict[str, EnumDef] | None = None,
+    type_dict: TypeDict | None = None,
     padding_alignment_bits: int = _DEFAULT_PADDING_ALIGNMENT_BITS,
 ) -> bytearray:
     """Encode decode() result into a bytearray.
@@ -271,10 +302,9 @@ def encode(
         The structure instance to encode.
     buf : bytearray
         The base bytearray instance to write into.
-    struct_def_dict : dict[str, StructDef] | None, optional
-        A dictionary of structure definitions, by default None.
-    enum_def_dict : dict[str, EnumDef] | None, optional
-        A dictionary of enum definitions, by default None.
+    type_dict : TypeDict | None, optional
+        Type dictionaries including structure and enum definitions,
+        by default None.
     padding_alignment_bits : int, optional
         The padding alignment boundary in bits, by default 32.
 
@@ -304,8 +334,7 @@ def encode(
             for i in range(field_def.repeat):
                 field_def_repeat = _split_repeated_field(
                     field_def, i, env, current_offset)
-                encode_field(field_def_repeat, values[i], buf, env,
-                             struct_def_dict, enum_def_dict,
+                encode_field(field_def_repeat, values[i], buf, env, type_dict,
                              padding_alignment_bits)
                 env[field_def_repeat.name] = values[i]
                 if isinstance(current_offset, InfoSize) and isinstance(
@@ -313,7 +342,7 @@ def encode(
                     current_offset += resolved_size
             continue
 
-        encode_field(field_def, value, buf, env, struct_def_dict, enum_def_dict,
+        encode_field(field_def, value, buf, env, type_dict,
                      padding_alignment_bits)
         env[field_def.name] = value
 
@@ -327,8 +356,7 @@ def decode_field(
     field_def: FieldDef,
     data: bytearray | bytes,
     env: dict[str, Any] | None = None,
-    struct_def_dict: dict[str, StructDef] | None = None,
-    enum_def_dict: dict[str, EnumDef] | None = None,
+    type_dict: TypeDict | None = None,
     padding_alignment_bits: int = _DEFAULT_PADDING_ALIGNMENT_BITS,
 ) -> FieldInstance | None:
     """Decode a single field from a bytearray according to a field definition.
@@ -341,8 +369,9 @@ def decode_field(
         The data to decode.
     env : dict[str, Any] | None, optional
         The environment for evaluating expressions, by default None.
-    struct_def_dict : dict[str, StructDef] | None, optional
-        A dictionary of structure definitions, by default None.
+    type_dict : TypeDict | None, optional
+        Type dictionaries including structure and enum definitions,
+        by default None.
     Returns
     -------
     FieldInstance | None
@@ -358,7 +387,7 @@ def decode_field(
     byte_swap = _resolve_byte_swap(field_def, env)
     if byte_swap:
         info = _byte_swap_info(info, size)
-    resolved_type = _resolve_field_type(field_def.type, struct_def_dict, env)
+    resolved_type = _resolve_field_type(field_def.type, type_dict, env)
     resolved_field_def = FieldDef(
         name=field_def.name,
         offset=offset,
@@ -374,40 +403,38 @@ def decode_field(
     if isinstance(resolved_type, StructDef):
         return FieldInstance(
             field_def=resolved_field_def,
-            value=decode(resolved_type, bytearray(info.to_bytes),
-                         struct_def_dict, enum_def_dict,
+            value=decode(resolved_type, bytearray(info.to_bytes), type_dict,
                          padding_alignment_bits),
         )
     if resolved_type == "bool":
         return FieldInstance.from_value(resolved_field_def,
                                         info.to_bool,
-                                        enum_def_dict=enum_def_dict)
+                                        type_dict=type_dict)
     if resolved_type == "signed int":
         return FieldInstance.from_value(resolved_field_def,
                                         info.to_signed_int,
-                                        enum_def_dict=enum_def_dict)
+                                        type_dict=type_dict)
     if resolved_type in ["int", "unsigned int"]:
         return FieldInstance.from_value(resolved_field_def,
                                         info.to_unsigned_int,
-                                        enum_def_dict=enum_def_dict)
+                                        type_dict=type_dict)
     if resolved_type == "float":
         return FieldInstance.from_value(resolved_field_def,
                                         info.to_float,
-                                        enum_def_dict=enum_def_dict)
+                                        type_dict=type_dict)
     if resolved_type in ["bytearray", "bytes"]:
         return FieldInstance.from_value(resolved_field_def,
                                         info.to_bytes,
-                                        enum_def_dict=enum_def_dict)
+                                        type_dict=type_dict)
     return FieldInstance.from_value(resolved_field_def,
                                     info.raw_value,
-                                    enum_def_dict=enum_def_dict)
+                                    type_dict=type_dict)
 
 
 def decode(
     struct_def: StructDef | list[FieldDef],
     data: bytearray | bytes,
-    struct_def_dict: dict[str, StructDef] | None = None,
-    enum_def_dict: dict[str, EnumDef] | None = None,
+    type_dict: TypeDict | None = None,
     padding_alignment_bits: int = _DEFAULT_PADDING_ALIGNMENT_BITS,
 ) -> StructInstance:
     """Decode a bytearray into field values according to a layout.
@@ -418,10 +445,9 @@ def decode(
         The definitions of the fields to decode.
     data : bytearray | bytes
         The data to decode.
-    struct_def_dict : dict[str, StructDef] | None, optional
-        A dictionary of structure definitions, by default None.
-    enum_def_dict : dict[str, EnumDef] | None, optional
-        A dictionary of enum definitions, by default None.
+    type_dict : TypeDict | None, optional
+        Type dictionaries including structure and enum definitions,
+        by default None.
     padding_alignment_bits : int, optional
         The padding alignment boundary in bits, by default 32.
     Returns
@@ -471,8 +497,8 @@ def decode(
         if field_def.repeat is None or field_def.repeat <= 1:
             resolved_offset = _resolve_offset(field_def, env)
             append_padding_until(resolved_offset)
-            field_instance = decode_field(field_def, data, env, struct_def_dict,
-                                          enum_def_dict, padding_alignment_bits)
+            field_instance = decode_field(field_def, data, env, type_dict,
+                                          padding_alignment_bits)
             if field_instance is not None:
                 env[field_instance.field_def.name] = field_instance.value
                 result.append_field_instance(field_instance)
@@ -487,8 +513,7 @@ def decode(
             field_def_repeat = _split_repeated_field(field_def, i, env,
                                                      current_offset)
             field_instance = decode_field(field_def_repeat, data, env,
-                                          struct_def_dict, enum_def_dict,
-                                          padding_alignment_bits)
+                                          type_dict, padding_alignment_bits)
             if field_instance is not None:
                 env[field_instance.field_def.name] = field_instance.value
                 result.append_field_instance(field_instance)
@@ -501,17 +526,19 @@ def decode(
 
 
 def _get_struct_def(
-        struct_def_name: str,
-        struct_def_dict: dict[str, StructDef] | None = None,
-        env: dict[str, Any] | None = None) -> StructDef | str | None:
+    struct_def_name: str,
+    type_dict: TypeDict | None = None,
+    env: dict[str, Any] | None = None,
+) -> StructDef | str | None:
     """Get a structure definition from a dictionary or evaluate it.
 
     Parameters
     ----------
     struct_def_name : str
         The name of the structure definition to get.
-    struct_def_dict : dict[str, StructDef] | None, optional
-        A dictionary of structure definitions, by default None.
+    type_dict : TypeDict | None, optional
+        Type dictionaries including structure and enum definitions,
+        by default None.
     env : dict[str, Any] | None, optional
         The environment for evaluating the structure definition,
         by default None.
@@ -521,8 +548,10 @@ def _get_struct_def(
     StructDef | str | None
         The structure definition, primitive type, or None if not found.
     """
-    if struct_def_dict and struct_def_name in struct_def_dict:
-        return struct_def_dict[struct_def_name]
+    struct_dict = None if type_dict is None else type_dict.struct_dict
+
+    if struct_dict and struct_def_name in struct_dict:
+        return struct_dict[struct_def_name]
 
     stleval = SltEval(env)
     try:
@@ -532,7 +561,7 @@ def _get_struct_def(
 
     if isinstance(eval_result, str) and eval_result in _PRIMITIVE_TYPES:
         return eval_result
-    if (isinstance(eval_result, str) and struct_def_dict
-            and eval_result in struct_def_dict):
-        return struct_def_dict[eval_result]
+    if (isinstance(eval_result, str) and struct_dict
+            and eval_result in struct_dict):
+        return struct_dict[eval_result]
     return None

{sltcodec-1.2.1 → sltcodec-1.3.0}/src/sltcodec/types.py

@@ -3,9 +3,10 @@ from __future__ import annotations
 
 import json
 import re
+from collections.abc import MutableMapping
 from dataclasses import dataclass, field
 from functools import total_ordering
-from typing import Any
+from typing import Any, Dict, Iterator, Optional
 
 from sltcalc import SltEval
 from sltcore import Info, InfoSize
@@ -336,10 +337,10 @@ class FieldInstance:
     def from_value(cls,
                    field_def: FieldDef,
                    value: Any,
-                   enum_def_dict: dict[str, EnumDef] | None = None,
+                   type_dict: "TypeDict | None" = None,
                    is_padding: bool = False) -> "FieldInstance":
         """Create a FieldInstance and attach a matched enum item if any."""
-        enum_def = cls._resolve_enum_def(field_def, enum_def_dict)
+        enum_def = cls._resolve_enum_def(field_def, type_dict)
         enum_item = cls._resolve_enum_item(enum_def, value)
         return cls(field_def=field_def,
                    value=value,
@@ -347,17 +348,19 @@ class FieldInstance:
                    is_padding=is_padding)
 
     @staticmethod
-    def _resolve_enum_def(
-            field_def: FieldDef,
-            enum_def_dict: dict[str, EnumDef] | None) -> EnumDef | None:
+    def _resolve_enum_def(field_def: FieldDef,
+                          type_dict: "TypeDict | None") -> EnumDef | None:
         """Resolve enum definition from field metadata or lookup dictionary."""
-        if not enum_def_dict:
+        if type_dict is None:
+            return None
+        enum_dict = type_dict.enum_dict
+        if len(enum_dict) == 0:
             return None
         if field_def.enum_def_name is not None:
-            return enum_def_dict.get(field_def.enum_def_name)
-        if isinstance(field_def.type, str) and field_def.type in enum_def_dict:
-            return enum_def_dict[field_def.type]
-        return enum_def_dict.get(field_def.name)
+            return enum_dict.get(field_def.enum_def_name)
+        if isinstance(field_def.type, str) and field_def.type in enum_dict:
+            return enum_dict[field_def.type]
+        return enum_dict.get(field_def.name)
 
     @staticmethod
     def _resolve_enum_item(enum_def: EnumDef | None,
@@ -596,3 +599,82 @@ class StructInstance:
 
         if max_end_offset > self.size:
             self.size = max_end_offset
+
+
+@dataclass
+class EnumDict(MutableMapping):
+    """A dictionary-like container for EnumDef objects."""
+    _items: Dict[str, "EnumDef"]
+
+    def __init__(self, items: Optional[Dict[str, "EnumDef"]] = None):
+        self._items = items or {}
+
+    def __getitem__(self, key: str) -> "EnumDef":
+        return self._items[key]
+
+    def __setitem__(self, key: str, value: "EnumDef"):
+        self._items[key] = value
+
+    def __delitem__(self, key: str):
+        del self._items[key]
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._items)
+
+    def __len__(self) -> int:
+        return len(self._items)
+
+    def items_dict(self) -> Dict[str, "EnumDef"]:
+        """Return the underlying dictionary of EnumDef objects.
+           Returns:
+               Dict[str, EnumDef]: The underlying dictionary
+               of EnumDef objects."""
+        return self._items
+
+
+@dataclass
+class StructDict(MutableMapping):
+    """A dictionary-like container for StructDef objects. """
+    _items: Dict[str, "StructDef"]
+
+    def __init__(self, items: Optional[Dict[str, "StructDef"]] = None):
+        self._items = items or {}
+
+    def __getitem__(self, key: str) -> "StructDef":
+        return self._items[key]
+
+    def __setitem__(self, key: str, value: "StructDef"):
+        self._items[key] = value
+
+    def __delitem__(self, key: str):
+        del self._items[key]
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._items)
+
+    def __len__(self) -> int:
+        return len(self._items)
+
+    def items_dict(self) -> Dict[str, "StructDef"]:
+        """Return the underlying dictionary of StructDef objects.
+           Returns:
+               Dict[str, StructDef]: The underlying dictionary
+               of StructDef objects."""
+        return self._items
+
+
+@dataclass
+class TypeDict:
+    """A dictionary-like container for EnumDef and StructDef objects."""
+    enum_dict: EnumDict
+    struct_dict: StructDict
+
+    def __init__(
+        self,
+        enum_dict: Optional[Dict[str, "EnumDef"]] = None,
+        struct_dict: Optional[Dict[str, "StructDef"]] = None,
+    ):
+        """Initialize TypeDict with optional EnumDef
+           and StructDef dictionaries."""
+        self.enum_dict = EnumDict(enum_dict)
+        self.struct_dict = StructDict(struct_dict)

{sltcodec-1.2.1 → sltcodec-1.3.0}/tests/test_codec.py

@@ -7,9 +7,8 @@ import pytest
 from sltcore import InfoSize
 
 from sltcodec import (PRIMITIVE_TYPES, EnumDef, FieldDef, FieldInstance,
-                      StructDef, StructInstance, decode, encode,
-                      load_enum_def_dict, load_struct_def_dict,
-                      save_enum_def_dict, save_struct_def_dict)
+                      StructDef, StructInstance, TypeDict, decode, encode,
+                      load_type_dict, save_type_dict)
 from sltcodec.codec import decode_field
 
 
@@ -402,10 +401,9 @@ def test_decode_uses_enum_def_dict_to_set_enum_item():
                          offset=InfoSize(0, 0),
                          size=InfoSize(1, 0),
                          type="unsigned int")
+    type_dict = TypeDict(enum_dict={"status": enum_def})
 
-    decoded = decode([field_def],
-                     bytearray(b"\x02"),
-                     enum_def_dict={"status": enum_def})
+    decoded = decode([field_def], bytearray(b"\x02"), type_dict=type_dict)
 
     assert decoded.field_instances[0].value == 2
     assert decoded.field_instances[0].enum_item == ("NG", 2)
@@ -421,7 +419,7 @@ def test_field_instance_from_value_sets_enum_item_from_field_enum_def():
                          enum_def_name=enum_def.name)
 
     field_instance = FieldInstance.from_value(
-        field_def, 1, enum_def_dict={enum_def.name: enum_def})
+        field_def, 1, type_dict=TypeDict(enum_dict={enum_def.name: enum_def}))
 
     assert field_instance.enum_item == ("MANUAL", 1)
 
@@ -460,8 +458,8 @@ def test_struct_instance_size_json_round_trip():
     assert struct_instance.size == InfoSize(8, 0)
 
 
-def test_struct_def_dict_load_and_save(tmp_path: Path):
-    """Test that a StructDef dictionary can be saved and reloaded."""
+def test_type_dict_load_and_save_struct_dict(tmp_path: Path):
+    """Test TypeDict save/load for struct definitions."""
     struct_def = StructDef(name="ValueStruct",
                            description="Single value struct",
                            fields=[
@@ -473,18 +471,19 @@ def test_struct_def_dict_load_and_save(tmp_path: Path):
                            ])
     path = tmp_path / "field_defs.json"
 
-    save_struct_def_dict(path, {"value": struct_def})
-    saved_field = json.loads(path.read_text())["value"]["fields"][0]
+    save_type_dict(path, TypeDict(struct_dict={"value": struct_def}))
+    saved_field = json.loads(
+        path.read_text())["struct_dict"]["value"]["fields"][0]
 
     assert isinstance(saved_field["offset"], dict)
     assert isinstance(saved_field["size"], dict)
-    loaded = load_struct_def_dict(path)
+    loaded = load_type_dict(path)
 
-    assert loaded["value"] == struct_def
+    assert loaded.struct_dict["value"] == struct_def
 
 
-def test_enum_def_dict_load_and_save(tmp_path: Path):
-    """Test that an EnumDef dictionary can be saved and reloaded."""
+def test_type_dict_load_and_save_enum_dict(tmp_path: Path):
+    """Test TypeDict save/load for enum definitions."""
     enum_def = EnumDef(name="Status",
                        description="Status enum",
                        values={
@@ -493,10 +492,10 @@ def test_enum_def_dict_load_and_save(tmp_path: Path):
                        })
     path = tmp_path / "enum_defs.json"
 
-    save_enum_def_dict(path, {"status": enum_def})
-    loaded = load_enum_def_dict(path)
+    save_type_dict(path, TypeDict(enum_dict={"status": enum_def}))
+    loaded = load_type_dict(path)
 
-    assert loaded["status"] == enum_def
+    assert loaded.enum_dict["status"] == enum_def
 
 
 def test_struct_def_to_json_from_json_round_trip():

{sltcodec-1.2.1 → sltcodec-1.3.0}/uv.lock

@@ -74,7 +74,7 @@ wheels = [
 
 [[package]]
 name = "sltcodec"
-version = "1.2.0"
+version = "1.2.1"
 source = { editable = "." }
 dependencies = [
     { name = "sltcalc" },

sltcodec-1.2.1/src/sltcodec/__init__.py

@@ -1,20 +0,0 @@
-from .codec import (PRIMITIVE_TYPES, decode, encode, encode_field,
-                    load_enum_def_dict, load_struct_def_dict,
-                    save_enum_def_dict, save_struct_def_dict)
-from .types import EnumDef, FieldDef, FieldInstance, StructDef, StructInstance
-
-__all__ = [
-    "PRIMITIVE_TYPES",
-    "EnumDef",
-    "FieldDef",
-    "FieldInstance",
-    "StructDef",
-    "StructInstance",
-    "decode",
-    "encode",
-    "encode_field",
-    "load_enum_def_dict",
-    "load_struct_def_dict",
-    "save_enum_def_dict",
-    "save_struct_def_dict",
-]