PyLibMS 3.0.8__tar.gz → 3.1.1__tar.gz

{pylibms-3.0.8 → pylibms-3.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyLibMS
-Version: 3.0.8
+Version: 3.1.1
 Summary: Python library built for the libMessageStudio (LMS) proprietary file formats from Nintendo. Supports MSBT, MSBP, and MSBF.
 Author: AbdyyEee
 License: Copyright 2025 AbdyyEee
@@ -20,20 +20,20 @@ Requires-Dist: PyYAML==6.0.1
 Dynamic: license-file
 
 # PylibMS
-Python library built in Python 3.10+ or the libMessageStudio (LMS) proprietary file formats from Nintendo. Supports the following:
+PylibMS is a library built in Python 3.10+ for the libMessageStudio (LMS) proprietary file formats from Nintendo. It supports the following:
 
 * Full reading and writing of MSBT files.
 * Full reading of MSBP files.
 * Supports encoded/decoded attributes and encoding/decoded tags.
 * Additonal tag manipulation.
 
-Games that work with the library, including but not limited to:
-* Tomodachi Life 
-* Nintendo Badge Arcade
-* The Legend of Zelda: A Link Between Worlds
-* Animal Crossing: Amiibo Festival
-* Super Mario 3D World
-* Super Mario 3D Land.
+This library is designed to support LMS revision 3.0 and above, with the associated file formats used across the following Nintendo platforms:
+* Wii (Specific titles only)
+* Nintendo 3DS
+* Wii U
+* Mobile (Specific titles only)
+* Nintendo Switch
+
 # Features and Usage
 Simple preview of the library is below. See [the wiki](https://github.com/AbdyyEee/PylibMS/wiki) for more explanations and examples.
 ## Reading 
@@ -50,7 +50,7 @@ from lms.message.msbtio import write_msbt_path
 write_msbt_path("Out_Game.msbt")
 ```
 # Adding/Editing Presets
-To add or edit Preset, you may create an issue with the relevant yaml file and the game it is for.
+To add or edit Preset, you may create an issue with the relevant `yaml` file and the game it is for. 
 
 # Installation
 ```

{pylibms-3.0.8 → pylibms-3.1.1}/PyLibMS.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyLibMS
-Version: 3.0.8
+Version: 3.1.1
 Summary: Python library built for the libMessageStudio (LMS) proprietary file formats from Nintendo. Supports MSBT, MSBP, and MSBF.
 Author: AbdyyEee
 License: Copyright 2025 AbdyyEee
@@ -20,20 +20,20 @@ Requires-Dist: PyYAML==6.0.1
 Dynamic: license-file
 
 # PylibMS
-Python library built in Python 3.10+ or the libMessageStudio (LMS) proprietary file formats from Nintendo. Supports the following:
+PylibMS is a library built in Python 3.10+ for the libMessageStudio (LMS) proprietary file formats from Nintendo. It supports the following:
 
 * Full reading and writing of MSBT files.
 * Full reading of MSBP files.
 * Supports encoded/decoded attributes and encoding/decoded tags.
 * Additonal tag manipulation.
 
-Games that work with the library, including but not limited to:
-* Tomodachi Life 
-* Nintendo Badge Arcade
-* The Legend of Zelda: A Link Between Worlds
-* Animal Crossing: Amiibo Festival
-* Super Mario 3D World
-* Super Mario 3D Land.
+This library is designed to support LMS revision 3.0 and above, with the associated file formats used across the following Nintendo platforms:
+* Wii (Specific titles only)
+* Nintendo 3DS
+* Wii U
+* Mobile (Specific titles only)
+* Nintendo Switch
+
 # Features and Usage
 Simple preview of the library is below. See [the wiki](https://github.com/AbdyyEee/PylibMS/wiki) for more explanations and examples.
 ## Reading 
@@ -50,7 +50,7 @@ from lms.message.msbtio import write_msbt_path
 write_msbt_path("Out_Game.msbt")
 ```
 # Adding/Editing Presets
-To add or edit Preset, you may create an issue with the relevant yaml file and the game it is for.
+To add or edit Preset, you may create an issue with the relevant `yaml` file and the game it is for. 
 
 # Installation
 ```

{pylibms-3.0.8 → pylibms-3.1.1}/README.md

@@ -1,18 +1,18 @@
 # PylibMS
-Python library built in Python 3.10+ or the libMessageStudio (LMS) proprietary file formats from Nintendo. Supports the following:
+PylibMS is a library built in Python 3.10+ for the libMessageStudio (LMS) proprietary file formats from Nintendo. It supports the following:
 
 * Full reading and writing of MSBT files.
 * Full reading of MSBP files.
 * Supports encoded/decoded attributes and encoding/decoded tags.
 * Additonal tag manipulation.
 
-Games that work with the library, including but not limited to:
-* Tomodachi Life 
-* Nintendo Badge Arcade
-* The Legend of Zelda: A Link Between Worlds
-* Animal Crossing: Amiibo Festival
-* Super Mario 3D World
-* Super Mario 3D Land.
+This library is designed to support LMS revision 3.0 and above, with the associated file formats used across the following Nintendo platforms:
+* Wii (Specific titles only)
+* Nintendo 3DS
+* Wii U
+* Mobile (Specific titles only)
+* Nintendo Switch
+
 # Features and Usage
 Simple preview of the library is below. See [the wiki](https://github.com/AbdyyEee/PylibMS/wiki) for more explanations and examples.
 ## Reading 
@@ -29,7 +29,7 @@ from lms.message.msbtio import write_msbt_path
 write_msbt_path("Out_Game.msbt")
 ```
 # Adding/Editing Presets
-To add or edit Preset, you may create an issue with the relevant yaml file and the game it is for.
+To add or edit Preset, you may create an issue with the relevant `yaml` file and the game it is for. 
 
 # Installation
 ```

{pylibms-3.0.8 → pylibms-3.1.1}/lms/common/lms_datatype.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import Literal, Type
+from typing import Type
 
 
 class LMS_DataType(Enum):

{pylibms-3.0.8 → pylibms-3.1.1}/lms/common/stream/hashtable.py

@@ -1,7 +1,7 @@
 from lms.fileio.io import FileReader, FileWriter
 
 
-def read_labels(reader: FileReader) -> tuple[dict[int, str], int]:
+def read_labels(reader: FileReader) -> tuple[dict, int]:
     labels = {}
 
     data_start = reader.tell()

{pylibms-3.0.8 → pylibms-3.1.1}/lms/common/stream/section.py

@@ -16,7 +16,6 @@ def read_section_data(
 
         yield (magic, size)
 
-        # Seek past the AB padding on next iteration
         reader.seek(end)
         reader.align(16)
 
@@ -26,7 +25,7 @@ def write_section(
     magic: str,
     section_call: Callable,
     data: list[Any],
-    *write_arguments,
+    *write_arguments: Any,
 ) -> None:
     writer.write_string(magic)
     size_offset = writer.tell()

{pylibms-3.0.8 → pylibms-3.1.1}/lms/fileio/encoding.py

@@ -1,29 +1,33 @@
-from enum import Enum
+from enum import IntEnum
 from typing import Literal
 
 
-class FileEncoding(Enum):
+class FileEncoding(IntEnum):
     """An enum that represents a file encoding."""
 
-    UTF8 = 0
-    UTF16 = 1
-    UTF32 = 2
+    UTF8 = 0x00
+    UTF16 = 0x01
+    UTF32 = 0x02
 
-    def to_string_format(self, big_endian: bool = False):
+    def to_string_format(
+        self, is_big_endian: bool = False
+    ) -> Literal["UTF-8", "UTF-16-BE", "UTF-16-LE", "UTF-32-BE", "UTF-32-LE"]:
+        """Converts the FileEncoding to string format."""
         match self:
             case FileEncoding.UTF8:
                 return "UTF-8"
             case FileEncoding.UTF16:
-                if big_endian:
+                if is_big_endian:
                     return "UTF-16-BE"
                 return "UTF-16-LE"
             case FileEncoding.UTF32:
-                if big_endian:
+                if is_big_endian:
                     return "UTF-32-BE"
                 return "UTF-32-LE"
 
     @property
-    def width(self):
+    def width(self) -> Literal[1, 2, 4]:
+        """The width of the encoding in the stream."""
         match self:
             case FileEncoding.UTF8:
                 return 1
@@ -33,5 +37,6 @@ class FileEncoding(Enum):
                 return 4
 
     @property
-    def terminator(self):
+    def terminator(self) -> bytes:
+        """The typical terminator for a string in the encoding."""
         return b"\x00" * self.width

{pylibms-3.0.8 → pylibms-3.1.1}/lms/fileio/io.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import struct
-from io import BytesIO
+from io import BytesIO, IOBase
 from typing import BinaryIO, Generator, cast
 
 from lms.fileio.encoding import FileEncoding
@@ -30,11 +30,12 @@ STRUCT_TYPES = {
 
 class FileReader:
     def __init__(self, data: BinaryIO | bytes, big_endian: bool = False):
-        if isinstance(data, bytes):
+        if isinstance(data, IOBase):
+            self._stream = data
+        elif isinstance(data, (bytes, bytearray, memoryview)):
             self._stream = BytesIO(data)
         else:
-            data = cast(BinaryIO, data)
-            self._stream = BytesIO(data.read())
+            raise TypeError("The stream provided is not valid!")
 
         self.encoding = FileEncoding.UTF8
         self.is_big_endian = big_endian
@@ -101,9 +102,7 @@ class FileReader:
         return message.decode(self.encoding.to_string_format(self.is_big_endian))
 
     def read_len_string_variable_encoding(self):
-        self.align(
-            len("\x00".encode(self.encoding.to_string_format(self.is_big_endian)))
-        )
+        self.align(self.encoding.width)
         length = self.read_uint16()
         return self.read_bytes(length).decode(
             self.encoding.to_string_format(self.is_big_endian)

{pylibms-3.0.8 → pylibms-3.1.1}/lms/message/definitions/field/io.py

@@ -35,20 +35,22 @@ def read_field(reader: FileReader, definition: ValueDefinition) -> LMS_Field:
 
 
 def write_field(writer: FileWriter, field: LMS_Field) -> None:
-    # All values are verifed before this point due to LMS_Field._verify_value
+    if isinstance(field.value, int):
+        value = cast(int, field.value)
+
     match field.datatype:
         case LMS_DataType.UINT8:
-            writer.write_uint8(cast(int, field.value))
+            writer.write_uint8(value)
         case LMS_DataType.INT8:
-            writer.write_int8(cast(int, field.value))
+            writer.write_int8(value)
         case LMS_DataType.UINT16:
-            writer.write_uint16(cast(int, field.value))
+            writer.write_uint16(value)
         case LMS_DataType.INT16:
-            writer.write_int16(cast(int, field.value))
+            writer.write_int16(value)
         case LMS_DataType.UINT32:
-            writer.write_uint32(cast(int, field.value))
+            writer.write_uint32(value)
         case LMS_DataType.INT32:
-            writer.write_int32(cast(int, field.value))
+            writer.write_int32(value)
         case LMS_DataType.LIST:
             writer.write_uint8(field.list_items.index(cast(str, field.value)))
         case LMS_DataType.BOOL:

{pylibms-3.0.8 → pylibms-3.1.1}/lms/message/definitions/field/lms_field.py

@@ -1,24 +1,73 @@
-from typing import Iterable, cast
+from __future__ import annotations
+
+from collections.abc import Iterator
+from dataclasses import dataclass, field
+from typing import cast
 
 from lms.common.lms_datatype import LMS_DataType
 from lms.titleconfig.definitions.value import ValueDefinition
 
-# Typehint that represents a map of strings to field instances.
-# Utilized as a means of storing attributes, or parameters in decoded tags mapped to their string names.
-type LMS_FieldMap = dict[str, LMS_Field]
+FLOAT_MIN = 1.17549435e-38
+FLOAT_MAX = 3.4028235e38
+
+
+type FieldValue = int | str | float | bool | bytes
+
+
+@dataclass(frozen=True)
+class LMS_FieldMap:
+    """
+    A wrapper for a dictionary of LMS_Field objects for easier access and abstraction from the dictionary object.
+    """
+
+    _fields: dict[str, LMS_Field]
+
+    def __iter__(self) -> Iterator[LMS_Field]:
+        return iter(self._fields.values())
 
+    def get_field(self, name: str) -> LMS_Field:
+        """
+        Returns the field associated with the name.
 
-def dict_to_field_map(data: dict, definitions: Iterable[ValueDefinition]):
-    return {
-        definition.name: LMS_Field(data[definition.name], definition)
-        for definition in definitions
-    }
+        :param name: the name of the field.
+        """
+        if name not in self._fields:
+            raise KeyError(f"Field '{name}' does not exist")
+
+        return self._fields[name]
+
+    def set_value(self, name: str, value: FieldValue) -> None:
+        """
+        Sets the value of the specified field.
+
+        :param name: the name of the field.
+        :param value: the new value for the field.
+        """
+        if name not in self._fields:
+            raise KeyError(f"Field '{name}' does not exist")
+
+        self._fields[name].value = value
+
+    def to_dict(self) -> dict[str, FieldValue]:
+        """Converts the field map to a regular dictionary."""
+        return {field.name: field.value for field in self._fields.values()}
+
+    @classmethod
+    def from_dict(cls, data: dict[str, FieldValue], definitions: list[ValueDefinition]):
+        return cls(
+            {
+                definition.name: LMS_Field(data[definition.name], definition)
+                for definition in definitions
+            }
+        )
 
 
 class LMS_Field:
-    """A class that represents a mapped field linked to a config definition.
+    """
+    A class that represents a mapped field linked to a config definition.
 
-    Acts as values for Attributes and Tag Parameters."""
+    Acts as values for Attributes and Tag Parameters.
+    """
 
     def __init__(
         self, value: int | str | float | bytes | bool, definition: ValueDefinition
@@ -29,11 +78,7 @@ class LMS_Field:
 
     def __repr__(self):
         if self.datatype is LMS_DataType.LIST:
-            if len(self.list_items) > 6:
-                preview = self.list_items[:3] + ["..."]
-            else:
-                preview = self.list_items
-            return f"LMS_Field(value={self._value}, options={preview})"
+            return f"LMS_Field(value={self._value}, list_items={self.list_items})"
         return f"LMS_Field(value={self._value}, type={self.datatype.name})"
 
     @property
@@ -58,7 +103,7 @@ class LMS_Field:
 
     @property
     def list_items(self) -> list[str]:
-        """The list items bound to the field instance. Only is valid for LMS_Datatype.LIST values."""
+        """The list items bound to the field instance. Only is valid for `LMS_Datatype.LIST` values."""
         return self._definition.list_items
 
     @value.setter
@@ -86,7 +131,7 @@ class LMS_Field:
                 else:
                     return
             case LMS_DataType.FLOAT32 if isinstance(value, float):
-                _verify_range(value, -3.4028235e38, 3.4028235e38, self._definition)
+                _verify_range(value, FLOAT_MIN, FLOAT_MAX, self._definition)
                 return
             case _ if isinstance(value, int):
                 bits = datatype.stream_size * 8

{pylibms-3.0.8 → pylibms-3.1.1}/lms/message/definitions/lms_messagetext.py

@@ -1,8 +1,8 @@
 import re
 
-from lms.message.definitions.field.lms_field import LMS_Field
+from lms.message.definitions.field.lms_field import LMS_FieldMap
 from lms.message.tag.lms_tag import (LMS_ControlTag, LMS_DecodedTag,
-                                     LMS_EncodedTag)
+                                     LMS_EncodedTag, is_tag)
 from lms.titleconfig.config import TagConfig
 
 
@@ -12,14 +12,16 @@ class LMS_MessageText:
     TAG_FORMAT = re.compile(r"(\[[^\]]+\])")
 
     def __init__(
-        self, message: str | list[str | LMS_ControlTag], config: TagConfig | None = None
+        self,
+        message: str | list[str | LMS_ControlTag],
+        tag_config: TagConfig | None = None,
     ):
         if isinstance(message, str):
             self._set_parts(message)
         else:
             self._parts = message
 
-        self._config = config
+        self._tag_config = tag_config
 
     def __iter__(self):
         return iter(self._parts)
@@ -27,14 +29,13 @@ class LMS_MessageText:
     @property
     def text(self) -> str:
         """The raw text of the message."""
-        text_list = []
+        result = []
         for part in self._parts:
-            text_list.append(
-                part.to_text()
-                if isinstance(part, (LMS_EncodedTag, LMS_DecodedTag))
-                else part
-            )
-        return "".join(text_list)
+            if is_tag(part):
+                result.append(part.to_text())
+            else:
+                result.append(part)
+        return "".join(result)
 
     @text.setter
     def text(self, string: str):
@@ -43,14 +44,13 @@ class LMS_MessageText:
     @property
     def tags(self) -> list[LMS_ControlTag]:
         """The list of control tags in the message."""
-        return [
-            part
-            for part in self._parts
-            if isinstance(part, (LMS_EncodedTag, LMS_DecodedTag))
-        ]
+        return [part for part in self._parts if is_tag(part)]
 
-    def append_encoded_tag(self, group_id: int, tag_index: int, *parameters: str):
-        """Appends an encoded tag to the current message.
+    def append_encoded_tag(
+        self, group_id: int, tag_index: int, is_closing: bool = False, *parameters: str
+    ) -> LMS_EncodedTag:
+        """
+        Appends an encoded tag to the current message and returns that tag.
 
         :param group: the group name or index.
         :param tag: the group tag or index:
@@ -61,15 +61,25 @@ class LMS_MessageText:
         message.append_encoded_tag(1, 2, "01", "00", "00", "CD")
         ```
         """
-        self._parts.append(LMS_EncodedTag(group_id, tag_index, list(parameters)))
+        if is_closing:
+            tag = LMS_EncodedTag(group_id, tag_index, is_closing=True)
+        else:
+            tag = LMS_EncodedTag(
+                group_id, tag_index, None if not parameters else list(parameters)
+            )
+
+        self._parts.append(tag)
+        return tag
 
     def append_decoded_tag(
         self,
         group_name: str,
         tag_name: str,
+        is_closing: bool = False,
         **parameters: int | str | float | bool | bytes,
-    ) -> None:
-        """Appends an decoded tag to the current message.
+    ) -> LMS_DecodedTag:
+        """
+        Appends an decoded tag to the current message and returns that tag.
 
         :param group_name: the group name.
         :param tag_name: the tag name.:
@@ -80,27 +90,38 @@ class LMS_MessageText:
         message.append_decoded_tag("Mii", "Nickname", buffer=1, type="Voice", conversion="None")
         ```
         """
-        if self._config is None:
+        if self._tag_config is None:
             raise ValueError("A TitleConfig is required to append decoded tags.")
 
-        definition = self._config.get_definition_by_names(group_name, tag_name)
+        definition = self._tag_config.get_definition_by_names(group_name, tag_name)
 
-        converted_params = {}
-        for param_def in definition.parameters:
-            converted_params[param_def.name] = LMS_Field(
-                parameters[param_def.name], param_def
-            )
+        param_map = None
+
+        if not parameters:
+            tag = LMS_DecodedTag(definition)
+            self._parts.append(tag)
+            return tag
 
-        self._parts.append(LMS_DecodedTag(definition, converted_params))
+        param_map = LMS_FieldMap.from_dict(parameters, definition.parameters)
+
+        if is_closing:
+            tag = LMS_DecodedTag(definition, is_closing=True)
+        else:
+            tag = LMS_DecodedTag(definition, param_map)
+
+        self._parts.append(tag)
+        return tag
 
     def append_tag_string(self, tag: str) -> None:
-        """Appends a tag to the current message given a string.
+        """
+        Appends a tag to the current message given a string.
 
-        :param tag: the tag string."""
+        :param tag: the tag string.
+        """
         if re.match(LMS_DecodedTag.TAG_FORMAT, tag):
-            if self._config is None:
+            if self._tag_config is None:
                 raise ValueError("TagConfig is required to append decoded tags.")
-            self._parts.append(LMS_DecodedTag.from_string(tag, self._config))
+            self._parts.append(LMS_DecodedTag.from_string(tag, self._tag_config))
         elif re.match(LMS_EncodedTag.TAG_FORMAT, tag):
             self._parts.append(LMS_EncodedTag.from_string(tag))
         else:

{pylibms-3.0.8 → pylibms-3.1.1}/lms/message/msbt.py

@@ -1,6 +1,7 @@
+from typing import overload
+
 from lms.common.lms_fileinfo import LMS_FileInfo
-from lms.message.definitions.field.lms_field import (LMS_Field,
-                                                     dict_to_field_map)
+from lms.message.definitions.field.lms_field import LMS_FieldMap
 from lms.message.definitions.lms_messagetext import LMS_MessageText
 from lms.message.msbtentry import MSBTEntry
 from lms.titleconfig.definitions.attribute import AttributeConfig
@@ -29,35 +30,44 @@ class MSBT:
         self.slot_count = 101
 
         self.attr_string_table: list[str] | bytes | None = None
-        self.encoded_attributes = True
+        self.uses_encoded_attributes = True
 
-        # List of section names to preserve order
+        self.unsupported_sections: dict[str, bytes] = {}
         self.section_list: list[str] = []
 
         # List of unsupported sections mapped to their raw data
-        self.unsupported_sections: dict[str, bytes] = {}
-
-        # Store configs so if new labels are added LMS_MessageText objects and Attributes can be made properly
         self._attribute_config = attribute_config
         self._tag_config = tag_config
 
     def __iter__(self):
         return iter(self._entries)
 
+    @property
+    def entries(self) -> list[MSBTEntry]:
+        """The list of entries for the MSBT instance."""
+        return self._entries
+
     @property
     def info(self) -> LMS_FileInfo:
         """The file info for the MSBT instance."""
         return self._info
 
     @property
-    def entries(self) -> list[MSBTEntry]:
-        """The list of entries for the MSBT instance."""
-        return self._entries
+    def has_attributes(self) -> bool:
+        """If the msbt contains attributs."""
+        return self.section_exists("ATR1")
+
+    @property
+    def has_style_indexes(self) -> bool:
+        """If the msbt contains style indexes."""
+        return self.section_exists("TSY1")
 
     def section_exists(self, name: str) -> bool:
-        """Determines if a section exists in the MSBT.
+        """
+        Determines if a section exists in the current MSBT.
 
-        :param name: the name of the section."""
+        :param name: the name of the section.
+        """
         return name in self.section_list
 
     def add_entry(
@@ -67,9 +77,14 @@ class MSBT:
         attribute: dict | bytes | None = None,
         style_index: int | None = None,
     ) -> None:
-        """Adds an entry to the MSBT instance.
-
-        :param name: the name of the entry."""
+        """
+        Adds an entry to the MSBT instance.
+
+        :param name: the name of the entry.
+        :param text: the message text to add.
+        :param attribute: the attribute data to add. can be a dictionary of data or raw bytes.
+        :param style_index: the index of a style for the message.
+        """
         if name in [entry.name for entry in self.entries]:
             raise KeyError(f"The label '{name}' already exists!")
 
@@ -78,22 +93,24 @@ class MSBT:
                 raise ValueError(
                     "The attribute config must have been provided when reading to add decoded attributes!"
                 )
-            converted_attribute = dict_to_field_map(
+            converted_attribute = LMS_FieldMap.from_dict(
                 attribute, self._attribute_config.definitions
             )
         else:
             converted_attribute = attribute
 
         if text is not None:
-            if self._tag_config is not None:
-                message_text = LMS_MessageText(text, self._tag_config)
-            else:
-                message_text = LMS_MessageText(text)
+            message_text = LMS_MessageText(text, self._tag_config)
         else:
             message_text = ""
 
         self._entries.append(
-            MSBTEntry(name, message_text, converted_attribute, style_index)
+            MSBTEntry(
+                name,
+                message=message_text,
+                attribute=converted_attribute,
+                style_index=style_index,
+            )
         )
 
     def get_entry(self, name: str) -> MSBTEntry: