PyLibMS 4.3.4__py3-none-any.whl → 5.0.0__py3-none-any.whl

lms/common/field/io.py

@@ -4,18 +4,18 @@ from lms.common.field.lms_datatype import (
     LMS_DataType,
     is_bool_datatype,
     is_bytes_datatype,
-    is_list_datatype,
+    is_enum_datatype,
     is_number_datatype,
 )
 from lms.common.field.lms_field import LMS_Field
 from lms.fileio.io import FileReader, FileWriter
-from lms.titleconfig.definitions.value import ValueDefinition
+from lms.titleconfig.definitions.field import FieldDefinition
 
 
 def read_field(
-    reader: FileReader,
-    definition: ValueDefinition,
-    read_variable_width_value: Callable | None = None,
+        reader: FileReader,
+        definition: FieldDefinition,
+        read_variable_width_value: Callable | None = None,
 ) -> LMS_Field:
     # String is excluded as their reading varies between MSBT/MSBF
     match definition.datatype:
@@ -33,27 +33,25 @@ def read_field(
             value = reader.read_int32()
         case LMS_DataType.FLOAT32:
             value = reader.read_float32()
-        case LMS_DataType.LIST:
+        case LMS_DataType.ENUM:
             if read_variable_width_value is not None:
                 index = read_variable_width_value()
             else:
                 index = reader.read_uint8()
-            value = definition.list_items[index]
+            value = definition.enum_members[index]
         case LMS_DataType.BOOL:
             if read_variable_width_value is not None:
                 value = bool(read_variable_width_value())
             else:
                 value = bool(reader.read_uint8())
-        case LMS_DataType.BYTES:
-            value = reader.read_bytes(1)
 
-    return LMS_Field(value, definition)  # type: ignore
+    return LMS_Field(value, definition)
 
 
 def write_field(
-    writer: FileWriter,
-    field: LMS_Field,
-    write_variable_width_value: Callable | None = None,
+        writer: FileWriter,
+        field: LMS_Field,
+        write_variable_width_value: Callable | None = None,
 ) -> None:
     if is_number_datatype(field.value, field.datatype):
         write_functions: dict[LMS_DataType, Callable] = {
@@ -68,8 +66,8 @@ def write_field(
         write_functions[field.datatype](field.value)
         return
 
-    if is_list_datatype(field.value, field.datatype):
-        value = field.list_items.index(field.value)
+    if is_enum_datatype(field.value, field.datatype):
+        value = list(field.enum_members.values()).index(field.value)
         if write_variable_width_value is not None:
             write_variable_width_value(value)
         else:

lms/common/field/lms_datatype.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from enum import Enum
+from enum import IntEnum, auto
 from typing import Type, TypeGuard
 
 FLOAT32_MIN = -3.4028235e38
@@ -15,8 +15,9 @@ ALIAS_MAP = {
     "i32": "INT32",
     "f32": "FLOAT32",
     "str": "STRING",
+    # LIST fallback for ENUM datatype
+    "list": "ENUM",
     "bool": "BOOL",
-    "byte": "BYTES",
 }
 
 
@@ -32,8 +33,8 @@ def is_number_datatype(value: object, datatype: LMS_DataType) -> TypeGuard[int |
     ) and isinstance(value, int)
 
 
-def is_list_datatype(value: object, datatype: LMS_DataType) -> TypeGuard[str]:
-    return datatype is LMS_DataType.LIST and isinstance(value, str)
+def is_enum_datatype(value: object, datatype: LMS_DataType) -> TypeGuard[str]:
+    return datatype is LMS_DataType.ENUM and isinstance(value, str)
 
 
 def is_bool_datatype(value: object, datatype: LMS_DataType) -> TypeGuard[bool]:
@@ -48,7 +49,7 @@ def is_string_datatype(value: object, datatype: LMS_DataType) -> TypeGuard[str]:
     return datatype is LMS_DataType.STRING and isinstance(value, str)
 
 
-class LMS_DataType(Enum):
+class LMS_DataType(IntEnum):
     """Enum that represents a datatype for a value entry in a MSBT/MSBP file."""
 
     UINT8 = 0
@@ -62,64 +63,56 @@ class LMS_DataType(Enum):
     FLOAT32 = 6
 
     STRING = 8
-    LIST = 9
+    ENUM = 9
 
-    # - Interface types -
-    # These types act as an abstraction for a real LMS_Datatype
-    # The actual value isn't important since they are not real types, but are instantiated from a config
-    BOOL = "bool"
-    BYTES = "byte"
-
-    def to_string(self) -> str:
-        return self._name_.lower()
+    # Interface type for UINT8
+    BOOL = auto()
 
     @property
     def signed(self) -> bool:
         """Property for if the type is signed or not."""
         if self not in [
-            LMS_DataType.STRING,
-            LMS_DataType.LIST,
-            LMS_DataType.BOOL,
-            LMS_DataType.BYTES,
+            self.STRING,
+            self.ENUM,
+            self.BOOL,
         ]:
-            return self in [LMS_DataType.INT8, LMS_DataType.INT16, LMS_DataType.INT32]
+            return self in [self.INT8, self.INT16, self.INT32]
 
-        raise TypeError(f"Signed is not a valid property for '{self.to_string()}'!")
+        raise TypeError(f"Signed is not a valid property for '{self.name.lower()}'!")
 
     @property
     def builtin_type(self) -> Type[int | float | str | bool | bytes]:
         """The enum as the builtin python type."""
         return {
-            LMS_DataType.UINT8: int,
-            LMS_DataType.UINT16: int,
-            LMS_DataType.UINT32: int,
-            LMS_DataType.INT8: int,
-            LMS_DataType.INT16: int,
-            LMS_DataType.INT32: int,
-            LMS_DataType.FLOAT32: float,
-            LMS_DataType.STRING: str,
-            LMS_DataType.LIST: str,
-            LMS_DataType.BOOL: bool,
-            LMS_DataType.BYTES: bytes,
+            self.UINT8: int,
+            self.UINT16: int,
+            self.UINT32: int,
+            self.INT8: int,
+            self.INT16: int,
+            self.INT32: int,
+            self.FLOAT32: float,
+            self.STRING: str,
+            self.ENUM: str,
+            self.BOOL: bool,
         }[self]
 
     @property
     def stream_size(self) -> int:
         """Size of the datatype, only for fixed integers."""
         sizes = {
-            LMS_DataType.UINT8: 1,
-            LMS_DataType.UINT16: 2,
-            LMS_DataType.UINT32: 4,
-            LMS_DataType.INT8: 1,
-            LMS_DataType.INT16: 2,
-            LMS_DataType.INT32: 4,
-            LMS_DataType.FLOAT32: 4,
+            self.UINT8: 1,
+            self.UINT16: 2,
+            self.UINT32: 4,
+            self.INT8: 1,
+            self.INT16: 2,
+            self.INT32: 4,
+            self.FLOAT32: 4,
         }
 
         try:
             return sizes[self]
         except KeyError:
-            raise TypeError(f"Stream size is not defined for '{self.to_string()}'.")
+            raise TypeError(f"Stream size is not defined for '{self.name.lower()}'.")
 
     @classmethod
     def from_string(cls, string: str):
@@ -136,8 +129,8 @@ class LMS_DataType(Enum):
 
 
 def verify_number_from_datatype(
-    value: int | float,
-    datatype: LMS_DataType,
+        value: int | float,
+        datatype: LMS_DataType,
 ):
     if datatype is LMS_DataType.FLOAT32:
         max_value = FLOAT32_MAX
@@ -148,7 +141,7 @@ def verify_number_from_datatype(
             max_value = 2 ** (bits - 1)
             min_value = -max_value
         else:
-            min_value, max_value = 0, (2**bits) - 1
+            min_value, max_value = 0, (2 ** bits) - 1
 
     if not min_value <= value <= max_value:
         raise ValueError(

lms/common/field/lms_field.py

@@ -1,21 +1,32 @@
 from __future__ import annotations
 
 from collections.abc import Iterator
-from dataclasses import dataclass
+from types import MappingProxyType
+from typing import Mapping, TypeAlias
 
 from lms.common.field.lms_datatype import LMS_DataType, verify_number_from_datatype
-from lms.titleconfig.definitions.value import ValueDefinition
+from lms.titleconfig.definitions.field import FieldDefinition
 
-type FieldValue = int | str | float | bool | bytes
+FieldValue: TypeAlias = int | str | float | bool | bytes
 
 
-@dataclass(frozen=True)
 class LMS_FieldMap:
     """
-    A wrapper for a basic ``dict[str, LMS_Field]``. Difference is validation upon modification of a field.
+    An immutable wrapper for a basic ``Mapping[str, LMS_Field]``.
+
+    Fields are validated by their datatype upon modification.
     """
 
-    fields: dict[str, LMS_Field]
+    def __init__(self, fields: Mapping[str, LMS_Field]) -> None:
+        self._fields = MappingProxyType(fields)
+
+    @property
+    def fields(self) -> Mapping[str, LMS_Field]:
+        """The fields associated to this LMS_FieldMap."""
+        return self._fields
+
+    def __len__(self) -> int:
+        return len(self.fields)
 
     def __iter__(self) -> Iterator[LMS_Field]:
         return iter(self.fields.values())
@@ -38,15 +49,15 @@ class LMS_FieldMap:
 
     @staticmethod
     def create_default_dict_map(
-        definitions: list[ValueDefinition],
+            definitions: list[FieldDefinition],
     ) -> dict[str, FieldValue]:
         map = {}
         for definition in definitions:
             match definition.datatype:
                 case LMS_DataType.STRING:
                     map[definition.name] = ""
-                case LMS_DataType.LIST:
-                    map[definition.name] = definition.list_items[0]
+                case LMS_DataType.ENUM:
+                    map[definition.name] = definition.enum_members[0]
                 case LMS_DataType.BOOL:
                     map[definition.name] = False
                 case LMS_DataType.FLOAT32:
@@ -56,11 +67,11 @@ class LMS_FieldMap:
         return map
 
     @classmethod
-    def create_default_map(cls, definitions: list[ValueDefinition]):
+    def create_default_map(cls, definitions: list[FieldDefinition]):
         return cls.from_dict(LMS_FieldMap.create_default_map(definitions), definitions)
 
     @classmethod
-    def from_dict(cls, data: dict[str, FieldValue], definitions: list[ValueDefinition]):
+    def from_dict(cls, data: dict[str, FieldValue], definitions: list[FieldDefinition]):
         return cls(
             {
                 definition.name: LMS_Field(data[definition.name], definition)
@@ -69,20 +80,18 @@ class LMS_FieldMap:
         )
 
     @classmethod
-    def from_string_dict(cls, data: dict[str, str], definitions: list[ValueDefinition]):
+    def from_string_dict(cls, data: dict[str, str], definitions: list[FieldDefinition]):
         fields = {}
         casted_value = None
 
         for definition in definitions:
             # These datatypes do not require any casting
-            if definition.datatype in (LMS_DataType.STRING, LMS_DataType.LIST):
+            if definition.datatype in (LMS_DataType.STRING, LMS_DataType.ENUM):
                 fields[definition.name] = LMS_Field(data[definition.name], definition)
                 continue
 
             value = data[definition.name]
             match definition.datatype:
-                case LMS_DataType.BYTES:
-                    casted_value = bytes.fromhex(value)
                 case LMS_DataType.BOOL:
                     if value not in ("false", "true"):
                         raise ValueError("Invalid boolean value!")
@@ -103,9 +112,9 @@ class LMS_Field:
     """
 
     def __init__(
-        self,
-        value: int | str | float | bytes | bool,
-        definition: ValueDefinition,
+            self,
+            value: int | str | float | bytes | bool,
+            definition: FieldDefinition,
     ):
         _verify_value_from_definition(value, definition)
         self._definition = definition
@@ -113,7 +122,7 @@ class LMS_Field:
 
     def __repr__(self):
         if self.datatype is LMS_DataType.LIST:
-            return f"LMS_Field(value={self._value!r}, list_items={self.list_items!r})"
+            return f"LMS_Field(value={self._value!r}, list_items={self.enum_members!r})"
 
         return f"LMS_Field(value={self._value!r}, type={self.datatype!r})"
 
@@ -138,9 +147,9 @@ class LMS_Field:
         return self._definition.datatype
 
     @property
-    def list_items(self) -> list[str]:
+    def enum_members(self) -> list[str]:
         """The list items bound to the field instance. Only is valid for ``LMS_Datatype.LIST`` values."""
-        return self._definition.list_items
+        return self._definition.enum_members
 
     @value.setter
     def value(self, new_value: int | str | float | bytes | bool):
@@ -149,7 +158,7 @@ class LMS_Field:
 
 
 def _verify_value_from_definition(
-    value: int | str | float | bytes | bool, definition: ValueDefinition
+        value: int | str | float | bytes | bool, definition: FieldDefinition
 ) -> None:
     datatype = definition.datatype
 
@@ -157,16 +166,11 @@ def _verify_value_from_definition(
         return
 
     match datatype:
-        case LMS_DataType.BYTES if isinstance(value, bytes):
-            if len(value) != 1:
-                raise ValueError("Byte types only work for values of length 1!")
-            else:
-                return
-        case LMS_DataType.LIST if isinstance(value, str):
-            if value not in definition.list_items:
+        case LMS_DataType.ENUM if isinstance(value, str):
+            if value not in definition.enum_members.values():
                 raise ValueError(
                     f"""The value of '{value}' provided for field '{definition.name}' is not a 
-                    valid item in the list {definition.list_items}."""
+                    valid item in the list {definition.enum_members}."""
                 )
             else:
                 return

lms/common/lms_constants.py

@@ -6,6 +6,7 @@ PADDING_BYTE = b"\x00"
 SIZE_OFFSET = 0x12
 SECTION_DATA_START = 0x20
 SECTION_PADDING_BYTE = b"\xab"
+SECTION_ALIGNMENT = 16
 
 LITTLE_ENDIAN_BOM = b"\xff\xfe"
 BIG_ENDIAN_BOM = b"\xfe\xff"

lms/common/stream/section.py

@@ -1,14 +1,10 @@
-from typing import Any, Callable, Generator
+from typing import Any, Callable, Generator, Sequence
 
+from lms.common.lms_constants import SECTION_ALIGNMENT, SECTION_PADDING_BYTE
 from lms.fileio.io import FileReader, FileWriter
 
-SECTION_PADDING_BYTE = b"\xab"
-SECTION_ALIGNMENT = 16
 
-
-def read_section_data(
-    reader: FileReader, section_count: int
-) -> Generator[tuple[str, int], Any, None]:
+def read_section_data(reader: FileReader, section_count: int) -> Generator[tuple[str, int], Any, None]:
     reader.seek(0x20)
     for _ in range(section_count):
         magic = reader.read_string_len(4)
@@ -20,15 +16,15 @@ def read_section_data(
         yield magic, size
 
         reader.seek(end)
-        reader.align(16)
+        reader.align(SECTION_ALIGNMENT)
 
 
 def write_section(
-    writer: FileWriter,
-    magic: str,
-    section_call: Callable,
-    data: list[Any],
-    *write_arguments: Any,
+        writer: FileWriter,
+        magic: str,
+        section_call: Callable,
+        data: Sequence[Any],
+        *write_arguments: Any,
 ) -> None:
     writer.write_string(magic)
     size_offset = writer.tell()

lms/fileio/io.py

@@ -1,47 +1,54 @@
 from __future__ import annotations
 
 import struct
-from typing import BinaryIO, Generator
+from enum import StrEnum
+from typing import BinaryIO, Generator, Type
 
-from io import BytesIO, IOBase
+from io import BytesIO, IOBase, TextIOBase
 from lms.fileio.encoding import FileEncoding
 
 PADDING_BYTE = b"\x00"
 
-STRUCT_TYPES = {
-    "little": {
-        "uint8": "<B",
-        "uint16": "<H",
-        "uint32": "<I",
-        "int8": "<b",
-        "int16": "<h",
-        "int32": "<i",
-        "float": "<f",
-    },
-    "big": {
-        "uint8": ">B",
-        "uint16": ">H",
-        "uint32": ">I",
-        "int8": ">b",
-        "int16": ">h",
-        "int32": ">i",
-        "float": ">f",
-    },
-}
+
+class StructLETypes(StrEnum):
+    UINT8 = "<B"
+    UINT16 = "<H"
+    UINT32 = "<I"
+    INT8 = "<b"
+    INT16 = "<h"
+    INT32 = "<i"
+    FLOAT32 = "<f"
+
+
+class StructBETypes(StrEnum):
+    UINT8 = ">B"
+    UINT16 = ">H"
+    UINT32 = ">I"
+    INT8 = ">b"
+    INT16 = ">h"
+    INT32 = ">i"
+    FLOAT32 = ">f"
 
 
 class FileReader:
-    def __init__(self, data: BinaryIO | bytes, big_endian: bool = False):
-        if isinstance(data, IOBase):
-            self._stream = data
-        elif isinstance(data, (bytes, bytearray, memoryview)):
-            self._stream = BytesIO(data)
-        else:
-            raise TypeError("The stream provided is not valid!")
+    def __init__(self, data: BinaryIO | bytes | bytearray | memoryview, big_endian: bool = False):
+        self._stream: BinaryIO = None
+
+        match data:
+            case IOBase() if not isinstance(data, TextIOBase):
+                self._stream = data
+            case bytes() | bytearray() | memoryview():
+                self._stream = BytesIO(data)
+            case _:
+                raise TypeError("The stream provided is not valid!")
 
         self.encoding = FileEncoding.UTF8
         self.is_big_endian = big_endian
 
+    @property
+    def datatypes(self) -> Type[StructLETypes | StructBETypes]:
+        return StructLETypes if not self.is_big_endian else StructBETypes
+
     def tell(self) -> int:
         return self._stream.tell()
 
@@ -49,17 +56,13 @@ class FileReader:
         self._stream.read(length)
 
     def align(self, alignment: int) -> None:
-        alignment = (-self.tell() % alignment + alignment) % alignment
-        self.skip(alignment)
+        self.skip((-self.tell() % alignment + alignment) % alignment)
 
     def read_bytes(self, length: int) -> bytes:
         return self._stream.read(length)
 
     def seek(self, offset: int, whence: int = 0) -> None:
-        if offset < 0:
-            self._stream.seek(self.tell() + offset)
-        else:
-            self._stream.seek(offset, whence)
+        self._stream.seek(self.tell() + offset) if offset < 0 else self._stream.seek(offset, whence)
 
     def read_offset_array(self, count: int) -> Generator[int, None, None]:
         start = self.tell() - 4
@@ -72,25 +75,25 @@ class FileReader:
         return [self.read_uint16() for _ in range(count)]
 
     def read_int8(self) -> int:
-        return struct.unpack(self._get_datatype("int8"), self._stream.read(1))[0]
+        return struct.unpack(self.datatypes.INT8, self._stream.read(1))[0]
 
     def read_int16(self) -> int:
-        return struct.unpack(self._get_datatype("int16"), self._stream.read(2))[0]
+        return struct.unpack(self.datatypes.INT16, self._stream.read(2))[0]
 
     def read_int32(self) -> int:
-        return struct.unpack(self._get_datatype("int32"), self._stream.read(4))[0]
+        return struct.unpack(self.datatypes.INT32, self._stream.read(4))[0]
 
     def read_uint8(self) -> int:
-        return struct.unpack(self._get_datatype("uint8"), self._stream.read(1))[0]
+        return struct.unpack(self.datatypes.UINT8, self._stream.read(1))[0]
 
     def read_uint16(self) -> int:
-        return struct.unpack(self._get_datatype("uint16"), self._stream.read(2))[0]
+        return struct.unpack(self.datatypes.UINT16, self._stream.read(2))[0]
 
     def read_uint32(self) -> int:
-        return struct.unpack(self._get_datatype("uint32"), self._stream.read(4))[0]
+        return struct.unpack(self.datatypes.UINT32, self._stream.read(4))[0]
 
     def read_float32(self) -> float:
-        return struct.unpack(self._get_datatype("float"), self._stream.read(4))[0]
+        return struct.unpack(self.datatypes.FLOAT32, self._stream.read(4))[0]
 
     def read_string_offset(self, section_start: int) -> str:
         offset = self.read_uint32()
@@ -104,12 +107,10 @@ class FileReader:
         return self._stream.read(length).decode("UTF-8")
 
     def read_encoded_string(self):
-        message = b""
-        while (
-            raw_char := self.read_bytes(self.encoding.width)
-        ) != self.encoding.terminator:
-            message += raw_char
-        return message.decode(self.encoding.to_string_format(self.is_big_endian))
+        string = b""
+        while (raw_char := self.read_bytes(self.encoding.width)) != self.encoding.terminator:
+            string += raw_char
+        return string.decode(self.encoding.to_string_format(self.is_big_endian))
 
     def read_len_string_encoded(self):
         self.align(self.encoding.width)
@@ -118,9 +119,6 @@ class FileReader:
             self.encoding.to_string_format(self.is_big_endian)
         )
 
-    def _get_datatype(self, name: str) -> str:
-        return STRUCT_TYPES["little" if not self.is_big_endian else "big"][name]
-
 
 class FileWriter:
     def __init__(self, encoding: FileEncoding):
@@ -128,6 +126,10 @@ class FileWriter:
         self.encoding = encoding
         self.is_big_endian = False
 
+    @property
+    def datatypes(self) -> Type[StructLETypes | StructBETypes]:
+        return StructLETypes if not self.is_big_endian else StructBETypes
+
     def skip(self, length: int) -> None:
         self.data.seek(length, 1)
 
@@ -155,34 +157,34 @@ class FileWriter:
             self.write_uint16(number)
 
     def write_int8(self, value: int) -> None:
-        self.data.write(struct.pack(self._get_datatype("int8"), value))
+        self.data.write(struct.pack(self.datatypes.INT8, value))
 
     def write_int16(self, value: int) -> None:
-        self.data.write(struct.pack(self._get_datatype("int16"), value))
+        self.data.write(struct.pack(self.datatypes.INT16, value))
 
     def write_int32(self, value: int) -> None:
-        self.data.write(struct.pack(self._get_datatype("int32"), value))
+        self.data.write(struct.pack(self.datatypes.INT32, value))
 
     def write_uint8(self, value: int) -> None:
-        self.data.write(struct.pack(self._get_datatype("uint8"), value))
+        self.data.write(struct.pack(self.datatypes.UINT8, value))
 
     def write_uint16(self, value: int) -> None:
-        self.data.write(struct.pack(self._get_datatype("uint16"), value))
+        self.data.write(struct.pack(self.datatypes.UINT16, value))
 
     def write_uint32(self, value: int) -> None:
-        self.data.write(struct.pack(self._get_datatype("uint32"), value))
+        self.data.write(struct.pack(self.datatypes.UINT32, value))
 
     def write_float32(self, value: float) -> None:
-        self.data.write(struct.pack(self._get_datatype("float"), value))
+        self.data.write(struct.pack(self.datatypes.FLOAT32, value))
 
-    def write_string(self, string: str):
+    def write_string(self, string: str) -> None:
         self.write_bytes(string.encode("UTF-8"))
 
     def write_len_encoded_string(self, string: str) -> None:
         self.write_uint16(len(string) * self.encoding.width)
         self.write_encoded_string(string, False)
 
-    def write_encoded_string(self, string: str, terminate: bool = True):
+    def write_encoded_string(self, string: str, terminate: bool = True) -> None:
         self.write_bytes(
             string.encode(self.encoding.to_string_format(self.is_big_endian))
         )
@@ -192,8 +194,5 @@ class FileWriter:
     def _align(self, number: int, alignment: int) -> int:
         return (-number % alignment + alignment) % alignment
 
-    def _get_datatype(self, name: str) -> str:
-        return STRUCT_TYPES["little" if not self.is_big_endian else "big"][name]
-
     def get_data(self) -> bytes:
         return self.data.getvalue()