PyLibMS 2.1.4__tar.gz → 3.0.2__tar.gz

{pylibms-2.1.4 → pylibms-3.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyLibMS
-Version: 2.1.4
+Version: 3.0.2
 Summary: Python library built for the libMessageStudio (LMS) proprietary file formats from Nintendo. Supports MSBT, MSBP, and MSBF.
 Author: AbdyyEee
 License: Copyright 2025 AbdyyEee
@@ -39,17 +39,15 @@ Simple preview of the library is below. See [the wiki](https://github.com/AbdyyE
 ## Reading 
 MSBT
 ```py
-from LMS.Message.MSBTStream import read_msbt
+from lms.message.msbtio import read_msbt_path
 
-with open("Game.msbt", "rb+") as f:
-    msbt = read_msbt(f)
+msbt = read_msbt_path("Game.msbt")
 ```
 ## Writing 
 ```py
-from LMS.Message.MSBTStream import write_msbt
+from lms.message.msbtio import write_msbt_path
 
-with open("Out.msbt", "wb") as f:
-    write_msbt(f, msbt)
+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.

{pylibms-2.1.4 → pylibms-3.0.2}/PyLibMS.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyLibMS
-Version: 2.1.4
+Version: 3.0.2
 Summary: Python library built for the libMessageStudio (LMS) proprietary file formats from Nintendo. Supports MSBT, MSBP, and MSBF.
 Author: AbdyyEee
 License: Copyright 2025 AbdyyEee
@@ -39,17 +39,15 @@ Simple preview of the library is below. See [the wiki](https://github.com/AbdyyE
 ## Reading 
 MSBT
 ```py
-from LMS.Message.MSBTStream import read_msbt
+from lms.message.msbtio import read_msbt_path
 
-with open("Game.msbt", "rb+") as f:
-    msbt = read_msbt(f)
+msbt = read_msbt_path("Game.msbt")
 ```
 ## Writing 
 ```py
-from LMS.Message.MSBTStream import write_msbt
+from lms.message.msbtio import write_msbt_path
 
-with open("Out.msbt", "wb") as f:
-    write_msbt(f, msbt)
+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.

pylibms-3.0.2/PyLibMS.egg-info/SOURCES.txt

@@ -0,0 +1,58 @@
+LICENSE
+README.md
+pyproject.toml
+PyLibMS.egg-info/PKG-INFO
+PyLibMS.egg-info/SOURCES.txt
+PyLibMS.egg-info/dependency_links.txt
+PyLibMS.egg-info/requires.txt
+PyLibMS.egg-info/top_level.txt
+lms/__init__.py
+lms/common/__init__.py
+lms/common/lms_datatype.py
+lms/common/lms_exceptions.py
+lms/common/lms_fileinfo.py
+lms/common/stream/fileinfo.py
+lms/common/stream/hashtable.py
+lms/common/stream/section.py
+lms/fileio/encoding.py
+lms/fileio/io.py
+lms/message/__init__.py
+lms/message/msbt.py
+lms/message/msbtentry.py
+lms/message/msbtio.py
+lms/message/definitions/__init__.py
+lms/message/definitions/lms_messagetext.py
+lms/message/definitions/field/__init__.py
+lms/message/definitions/field/io.py
+lms/message/definitions/field/lms_field.py
+lms/message/section/__init__.py
+lms/message/section/atr1.py
+lms/message/section/tsy1.py
+lms/message/section/txt2.py
+lms/message/tag/__init__.py
+lms/message/tag/lms_tag.py
+lms/message/tag/lms_tagexceptions.py
+lms/message/tag/io/param_io.py
+lms/message/tag/io/tag_io.py
+lms/project/__init__.py
+lms/project/msbp.py
+lms/project/msbpread.py
+lms/project/definitions/__init__.py
+lms/project/definitions/attribute.py
+lms/project/definitions/color.py
+lms/project/definitions/style.py
+lms/project/definitions/tag.py
+lms/project/section/ali2.py
+lms/project/section/ati2.py
+lms/project/section/clr1.py
+lms/project/section/string.py
+lms/project/section/syl3.py
+lms/project/section/tag2.py
+lms/project/section/tgg2.py
+lms/project/section/tgp2.py
+lms/titleconfig/__init__.py
+lms/titleconfig/config.py
+lms/titleconfig/definitions/__init__.py
+lms/titleconfig/definitions/attribute.py
+lms/titleconfig/definitions/tags.py
+lms/titleconfig/definitions/value.py

pylibms-3.0.2/PyLibMS.egg-info/top_level.txt

@@ -0,0 +1 @@
+lms

{pylibms-2.1.4 → pylibms-3.0.2}/README.md

@@ -18,17 +18,15 @@ Simple preview of the library is below. See [the wiki](https://github.com/AbdyyE
 ## Reading 
 MSBT
 ```py
-from LMS.Message.MSBTStream import read_msbt
+from lms.message.msbtio import read_msbt_path
 
-with open("Game.msbt", "rb+") as f:
-    msbt = read_msbt(f)
+msbt = read_msbt_path("Game.msbt")
 ```
 ## Writing 
 ```py
-from LMS.Message.MSBTStream import write_msbt
+from lms.message.msbtio import write_msbt_path
 
-with open("Out.msbt", "wb") as f:
-    write_msbt(f, msbt)
+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.

pylibms-2.1.4/LMS/Common/LMS_DataType.py → pylibms-3.0.2/lms/common/lms_datatype.py

@@ -4,6 +4,7 @@ from typing import Literal, Type
 
 class LMS_DataType(Enum):
     """Enum that represents a datatype for a value entry in a MSBT/MSBP file."""
+
     UINT8 = 0
     UINT16 = 1
     UINT32 = 2
@@ -22,12 +23,12 @@ class LMS_DataType(Enum):
 
     STRING = 8
     LIST = 9
- 
+
     # These types are not offical, but allow for abstraction from the value of the actual type
     # As an example, BOOL can be utilized for UInt8 values that act like a bool
     # Byte types can also be used for when the type/value is unknown or if there is extra data in the tag.
     BOOL = "bool"
-    BYTE = "byte"
+    BYTES = "byte"
 
     def to_string(self) -> str:
         return self._name_.lower()
@@ -39,7 +40,7 @@ class LMS_DataType(Enum):
             LMS_DataType.STRING,
             LMS_DataType.LIST,
             LMS_DataType.BOOL,
-            LMS_DataType.BYTE,
+            LMS_DataType.BYTES,
         ]:
             return self in [LMS_DataType.INT8, LMS_DataType.INT16, LMS_DataType.INT32]
 
@@ -59,11 +60,11 @@ class LMS_DataType(Enum):
             LMS_DataType.STRING: str,
             LMS_DataType.LIST: str,
             LMS_DataType.BOOL: bool,
-            LMS_DataType.BYTE: bytes,
+            LMS_DataType.BYTES: bytes,
         }[self]
 
     @property
-    def stream_size(self) -> Literal[1, 2, 4]:
+    def stream_size(self):
         """The size the datatype takes up in a stream."""
         return {
             LMS_DataType.UINT8: 1,
@@ -75,7 +76,7 @@ class LMS_DataType(Enum):
             LMS_DataType.FLOAT32: 4,
             LMS_DataType.LIST: 1,
             LMS_DataType.BOOL: 1,
-            LMS_DataType.BYTE: 1,
+            LMS_DataType.BYTES: 1,
         }[self]
 
     @classmethod

pylibms-3.0.2/lms/common/lms_exceptions.py

@@ -0,0 +1,7 @@
+class LMS_Error(Exception): ...
+
+
+class LMS_UnexpectedMagicError(Exception): ...
+
+
+class LMS_MisalignedSizeError(Exception): ...

pylibms-2.1.4/LMS/Common/LMS_FileInfo.py → pylibms-3.0.2/lms/common/lms_fileinfo.py

@@ -1,11 +1,11 @@
 from dataclasses import dataclass
 
-from LMS.FileIO.Encoding import FileEncoding
+from lms.fileio.encoding import FileEncoding
 
 
 @dataclass(frozen=True)
 class LMS_FileInfo:
-    big_endian: bool
+    is_big_endian: bool
     encoding: FileEncoding
     version: int
     section_count: int

pylibms-2.1.4/LMS/Common/Stream/FileInfo.py → pylibms-3.0.2/lms/common/stream/fileinfo.py

@@ -1,19 +1,19 @@
-from LMS.Common import LMS_Exceptions
-from LMS.Common.LMS_FileInfo import LMS_FileInfo
-from LMS.FileIO.Encoding import FileEncoding
-from LMS.FileIO.Stream import FileReader, FileWriter
+from lms.common import lms_exceptions
+from lms.common.lms_fileinfo import LMS_FileInfo
+from lms.fileio.encoding import FileEncoding
+from lms.fileio.io import FileReader, FileWriter
 
 
 def read_file_info(reader: FileReader, expected_magic: str) -> LMS_FileInfo:
     magic = reader.read_string_len(8)
 
     if magic != expected_magic:
-        raise LMS_Exceptions.LMS_UnexpectedMagicError(
+        raise lms_exceptions.LMS_UnexpectedMagicError(
             f"Invalid magic!' Expected {expected_magic}', got '{magic}'."
         )
 
-    big_endian = reader.read_bytes(2) == b"\xfe\xff"
-    reader.big_endian = big_endian
+    is_big_endian = reader.read_bytes(2) == b"\xfe\xff"
+    reader.is_big_endian = is_big_endian
 
     reader.skip(2)
 
@@ -28,13 +28,13 @@ def read_file_info(reader: FileReader, expected_magic: str) -> LMS_FileInfo:
 
     reader.seek(0, 2)
     if file_size != reader.tell():
-        raise LMS_Exceptions.LMS_MisalignedSizeError(f"Filesize is misaligned!")
+        raise lms_exceptions.LMS_MisalignedSizeError(f"Filesize is misaligned!")
 
     # Seek to the start of data
     reader.seek(0x20)
 
     return LMS_FileInfo(
-        big_endian,
+        is_big_endian,
         encoding,
         version,
         section_count,
@@ -46,18 +46,17 @@ def write_file_info(writer: FileWriter, magic: str, file_info: LMS_FileInfo) ->
 
     :param writer: a Writer object.
     :param file_info: the file_info object."""
-    writer.big_endian = file_info.big_endian
+    writer.is_big_endian = file_info.is_big_endian
     writer.encoding = file_info.encoding
 
     writer.write_string(magic)
-    writer.write_bytes(b"\xff\xfe" if not file_info.big_endian else b"\xfe\xff")
+    writer.write_bytes(b"\xff\xfe" if not file_info.is_big_endian else b"\xfe\xff")
     writer.write_bytes(b"\x00\x00")
 
     writer.write_uint8(file_info.encoding.value)
     writer.write_uint8(file_info.version)
     writer.write_uint16(file_info.section_count)
 
-    # Padding
     writer.write_bytes(b"\x00\x00")
     writer.write_bytes(b"\x00" * 4)
     writer.write_bytes(b"\x00" * 10)

pylibms-2.1.4/LMS/Common/Stream/Hashtable.py → pylibms-3.0.2/lms/common/stream/hashtable.py

@@ -1,4 +1,4 @@
-from LMS.FileIO.Stream import FileReader, FileWriter
+from lms.fileio.io import FileReader, FileWriter
 
 
 def read_labels(reader: FileReader) -> tuple[dict[int, str], int]:
@@ -7,12 +7,10 @@ def read_labels(reader: FileReader) -> tuple[dict[int, str], int]:
     data_start = reader.tell()
     slot_count = reader.read_uint32()
     for _ in range(slot_count):
-        # Read initial label data
         label_count = reader.read_uint32()
         offset = reader.read_uint32()
         next_offset = reader.tell()
 
-        # Read the actual label data
         reader.seek(data_start + offset)
         for _ in range(label_count):
             length = reader.read_uint8()
@@ -26,16 +24,10 @@ def read_labels(reader: FileReader) -> tuple[dict[int, str], int]:
 
     # While the slot count is consistent for most files, some vary them.
     # Return the slot count to ensure that this change can be recorded.
-    return (sorted_labels, slot_count)
+    return sorted_labels, slot_count
 
 
 def write_labels(writer: FileWriter, labels: list[str], slot_count: int) -> None:
-    """Writes the hashtable block to a stream.
-
-    :param writer: a Writer object.
-    :param labels: the dictionary of labels.
-    :param slot_count: the amount of hash slots.
-    """
     writer.write_uint32(slot_count)
 
     hash_slots = {}
@@ -44,19 +36,18 @@ def write_labels(writer: FileWriter, labels: list[str], slot_count: int) -> None
     for i, label in enumerate(labels):
         hash = _calculate_hash(label, slot_count)
 
-        # Add to the list if hash exists, and create a new list for each new hash
         if hash not in hash_slots:
             hash_slots[hash] = [label]
         else:
             hash_slots[hash].append(label)
 
         index_map[label] = i
+
     label_offsets = slot_count * 8 + 4
 
-    # Sort by the hash slots
     hash_slots = dict(sorted(hash_slots.items(), key=lambda x: x[0]))
 
-    # Write the slots
+
     for i in range(slot_count):
         if i in hash_slots:
             writer.write_uint32(len(hash_slots[i]))
@@ -76,11 +67,8 @@ def write_labels(writer: FileWriter, labels: list[str], slot_count: int) -> None
             writer.write_uint32(index_map[label])
 
 
+#  See https://nintendo-formats.com/libs/lms/overview.html#hash-tables
 def _calculate_hash(label: str, slot_count: int) -> int:
-    """Calculates the hash of a label.
-
-    See https://nintendo-formats.com/libs/lms/overview.html#hash-tables
-    """
     hash = 0
     for character in label:
         hash = hash * 0x492 + ord(character)

pylibms-2.1.4/LMS/Common/Stream/Section.py → pylibms-3.0.2/lms/common/stream/section.py

@@ -1,6 +1,6 @@
 from typing import Any, Callable, Generator
 
-from LMS.FileIO.Stream import FileReader, FileWriter
+from lms.fileio.io import FileReader, FileWriter
 
 
 def read_section_data(
@@ -11,7 +11,6 @@ def read_section_data(
         magic = reader.read_string_len(4)
         size = reader.read_uint32()
 
-        # Skip to start of data
         reader.skip(8)
         end = reader.tell() + size
 
@@ -27,7 +26,7 @@ def write_section(
     magic: str,
     section_call: Callable,
     data: list[Any],
-    *write_parameters,
+    *write_arguments,
 ) -> None:
     writer.write_string(magic)
     size_offset = writer.tell()
@@ -36,7 +35,7 @@ def write_section(
     writer.write_bytes(b"\x00" * 8)
     data_start = writer.tell()
 
-    section_call(writer, data, *write_parameters)
+    section_call(writer, data, *write_arguments)
 
     _write_end_data(writer, data_start, size_offset)
 
@@ -57,4 +56,4 @@ def _write_end_data(writer: FileWriter, data_start: int, size_offset: int) -> No
     writer.seek(size_offset)
     writer.write_uint32(size)
     writer.seek(end)
-    writer.write_alignment(b"\xAB", 16)
+    writer.write_alignment(b"\xab", 16)

pylibms-2.1.4/LMS/FileIO/Encoding.py → pylibms-3.0.2/lms/fileio/encoding.py

@@ -11,8 +11,7 @@ class FileEncoding(Enum):
 
     def to_string_format(
         self, big_endian: bool = False
-    ) -> Literal["UTF-8", "UTF-16-LE", "UTF-16-BE", "UTF-32-LE", "UTF-32-BE"]:
-        """Returns the encoding in the string format"""
+    ):
         match self:
             case FileEncoding.UTF8:
                 return "UTF-8"
@@ -26,8 +25,7 @@ class FileEncoding(Enum):
                 return "UTF-32-LE"
 
     @property
-    def width(self) -> Literal[1, 2, 4]:
-        """The width of a character in a stream."""
+    def width(self):
         match self:
             case FileEncoding.UTF8:
                 return 1
@@ -37,6 +35,5 @@ class FileEncoding(Enum):
                 return 4
 
     @property
-    def terminator(self) -> Literal[b"\x00", b"\x00\x00", b"\x00\x00\x00\x00"]:
-        """The terminator of the string in a stream."""
+    def terminator(self):
         return b"\x00" * self.width

pylibms-2.1.4/LMS/FileIO/Stream.py → pylibms-3.0.2/lms/fileio/io.py

@@ -4,7 +4,7 @@ import struct
 from io import BytesIO
 from typing import BinaryIO, Generator
 
-from LMS.FileIO.Encoding import FileEncoding
+from lms.fileio.encoding import FileEncoding
 
 STRUCT_TYPES = {
     "little": {
@@ -28,34 +28,34 @@ STRUCT_TYPES = {
 }
 
 
-class FileReader:
-    def __init__(self, stream: BinaryIO | bytes, big_endian: bool = False):
-        if isinstance(stream, bytes):
-            self._data = BytesIO(stream)
+class FileReader: 
+    def __init__(self, data: BinaryIO | bytes, big_endian: bool = False):
+        if isinstance(data, BinaryIO):
+            self._stream = BytesIO(data.read())
         else:
-            self._data = BytesIO(stream.read())
+            self._stream = BytesIO(data) 
 
-        self.encoding: FileEncoding = None
-        self.big_endian = big_endian
+        self.encoding = FileEncoding.UTF8
+        self.is_big_endian = big_endian
 
     def tell(self) -> int:
-        return self._data.tell()
+        return self._stream.tell()
 
     def skip(self, length: int) -> None:
-        self._data.read(length)
+        self._stream.read(length)
 
-    def align(self, alignment: int) -> int:
+    def align(self, alignment: int) -> None:
         alignment = (-self.tell() % alignment + alignment) % alignment
         self.skip(alignment)
 
     def read_bytes(self, length: int) -> bytes:
-        return self._data.read(length)
+        return self._stream.read(length)
 
     def seek(self, offset: int, whence: int = 0) -> None:
         if offset < 0:
-            self._data.seek(self.tell() + offset)
+            self._stream.seek(self.tell() + offset)
         else:
-            self._data.seek(offset, whence)
+            self._stream.seek(offset, whence)
 
     def read_offset_array(self, count: int) -> Generator[int, None, None]:
         start = self.tell() - 4
@@ -68,28 +68,28 @@ class FileReader:
         return [self.read_uint16() for _ in range(count)]
 
     def read_int8(self) -> int:
-        return struct.unpack(self._get_datatype("int8"), self._data.read(1))[0]
+        return struct.unpack(self._get_datatype("int8"), self._stream.read(1))[0]
 
     def read_int16(self) -> int:
-        return struct.unpack(self._get_datatype("int16"), self._data.read(2))[0]
+        return struct.unpack(self._get_datatype("int16"), self._stream.read(2))[0]
 
     def read_int32(self) -> int:
-        return struct.unpack(self._get_datatype("int32"), self._data.read(4))[0]
+        return struct.unpack(self._get_datatype("int32"), self._stream.read(4))[0]
 
     def read_uint8(self) -> int:
-        return struct.unpack(self._get_datatype("uint8"), self._data.read(1))[0]
+        return struct.unpack(self._get_datatype("uint8"), self._stream.read(1))[0]
 
     def read_uint16(self) -> int:
-        return struct.unpack(self._get_datatype("uint16"), self._data.read(2))[0]
+        return struct.unpack(self._get_datatype("uint16"), self._stream.read(2))[0]
 
     def read_uint32(self) -> int:
-        return struct.unpack(self._get_datatype("uint32"), self._data.read(4))[0]
+        return struct.unpack(self._get_datatype("uint32"), self._stream.read(4))[0]
 
     def read_float32(self) -> float:
-        return struct.unpack(self._get_datatype("float"), self._data.read(4))[0]
+        return struct.unpack(self._get_datatype("float"), self._stream.read(4))[0]
 
     def read_string_len(self, length: int) -> str:
-        return self._data.read(length).decode("UTF-8")
+        return self._stream.read(length).decode("UTF-8")
 
     def read_str_variable_encoding(self):
         message = b""
@@ -97,24 +97,26 @@ class FileReader:
             raw_char := self.read_bytes(self.encoding.width)
         ) != self.encoding.terminator:
             message += raw_char
-        return message.decode(self.encoding.to_string_format(self.big_endian))
+        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.big_endian))))
+        self.align(
+            len("\x00".encode(self.encoding.to_string_format(self.is_big_endian)))
+        )
         length = self.read_uint16()
         return self.read_bytes(length).decode(
-            self.encoding.to_string_format(self.big_endian)
+            self.encoding.to_string_format(self.is_big_endian)
         )
 
     def _get_datatype(self, name: str) -> str:
-        return STRUCT_TYPES["little" if not self.big_endian else "big"][name]
+        return STRUCT_TYPES["little" if not self.is_big_endian else "big"][name]
 
 
 class FileWriter:
     def __init__(self, encoding: FileEncoding):
         self.data = BytesIO(b"")
         self.encoding = encoding
-        self.big_endian = False
+        self.is_big_endian = False
 
     def skip(self, length: int) -> None:
         self.data.seek(length, 1)
@@ -126,8 +128,8 @@ class FileWriter:
         self.seek(last_position)
         return size
 
-    def write_bytes(self, data: bytes) -> bytes:
-        return self.data.write(data)
+    def write_bytes(self, data: bytes) -> None:
+        self.data.write(data)
 
     def seek(self, offset: int, whence: int = 0) -> None:
         self.data.seek(offset, whence)
@@ -142,38 +144,38 @@ class FileWriter:
         for number in array:
             self.write_uint16(number)
 
-    def write_int8(self, value: int) -> int:
-        return self.data.write(struct.pack(self._get_datatype("int8"), value))
+    def write_int8(self, value: int) -> None:
+        self.data.write(struct.pack(self._get_datatype("int8"), value))
 
-    def write_int16(self, value: int) -> int:
-        return self.data.write(struct.pack(self._get_datatype("int16"), value))
+    def write_int16(self, value: int) -> None:
+        self.data.write(struct.pack(self._get_datatype("int16"), value))
 
     def write_int32(self, value: int) -> None:
-        return self.data.write(struct.pack(self._get_datatype("int32"), value))
+       self.data.write(struct.pack(self._get_datatype("int32"), value))
 
     def write_uint8(self, value: int) -> None:
-        return self.data.write(struct.pack(self._get_datatype("uint8"), value))
+        self.data.write(struct.pack(self._get_datatype("uint8"), value))
 
     def write_uint16(self, value: int) -> None:
-        return self.data.write(struct.pack(self._get_datatype("uint16"), value))
+        self.data.write(struct.pack(self._get_datatype("uint16"), value))
 
     def write_uint32(self, value: int) -> None:
-        return self.data.write(struct.pack(self._get_datatype("uint32"), value))
+        self.data.write(struct.pack(self._get_datatype("uint32"), value))
 
     def write_float32(self, value: float) -> None:
-        return self.data.write(struct.pack(self._get_datatype("float"), value))
+        self.data.write(struct.pack(self._get_datatype("float"), value))
 
     def write_string(self, string: str):
         self.write_bytes(string.encode("UTF-8"))
 
     def write_len_variable_encoding_string(self, string: str) -> None:
         self.write_uint16(len(string) * self.encoding.width)
-        self.write_variable_encoding_string.write_variable_encoding_string(
-            string, False
-        )
+        self.write_variable_encoding_string(string, False)
 
     def write_variable_encoding_string(self, string: str, terminate: bool = True):
-        self.write_bytes(string.encode(self.encoding.to_string_format(self.big_endian)))
+        self.write_bytes(
+            string.encode(self.encoding.to_string_format(self.is_big_endian))
+        )
         if terminate:
             self.write_bytes(b"\x00" * self.encoding.width)
 
@@ -181,7 +183,7 @@ class FileWriter:
         return (-number % alignment + alignment) % alignment
 
     def _get_datatype(self, name: str) -> str:
-        return STRUCT_TYPES["little" if not self.big_endian else "big"][name]
+        return STRUCT_TYPES["little" if not self.is_big_endian else "big"][name]
 
     def get_data(self) -> bytes:
         return self.data.getvalue()