PyLibMS 2.0.0__py3-none-any.whl

LMS/Common/LMS_Exceptions.py

@@ -0,0 +1,16 @@
+class LMS_Error(Exception):
+    """Exception for non-specifc errors"""
+
+    pass
+
+
+class LMS_UnexpectedMagicError(Exception):
+    """Exception for wrong magic of a LMS file"""
+
+    pass
+
+
+class LMS_MisalignedSizeError(Exception):
+    """Exception for when size is not aligned."""
+
+    pass

LMS/Common/LMS_FileInfo.py

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

LMS/Common/Stream/FileInfo.py

@@ -0,0 +1,64 @@
+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
+
+
+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(
+            f"Invalid magic!' Expected {expected_magic}', got '{magic}'."
+        )
+
+    big_endian = reader.read_bytes(2) == b"\xfe\xff"
+    reader.big_endian = big_endian
+
+    reader.skip(2)
+
+    encoding = FileEncoding(reader.read_uint8())
+    reader.encoding = encoding
+
+    version = reader.read_uint8()
+    section_count = reader.read_uint16()
+
+    reader.skip(2)
+    file_size = reader.read_uint32()
+
+    reader.seek(0, 2)
+    if file_size != reader.tell():
+        raise LMS_Exceptions.LMS_MisalignedSizeError(f"Filesize is misaligned!")
+
+    # Seek to the start of data
+    reader.seek(0x20)
+
+    return LMS_FileInfo(
+        big_endian,
+        encoding,
+        version,
+        section_count,
+    )
+
+
+def write_file_info(writer: FileWriter, magic: str, file_info: LMS_FileInfo) -> None:
+    """Writes the file info to a stream.
+
+    :param writer: a Writer object.
+    :param file_info: the file_info object."""
+    writer.big_endian = file_info.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"\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)
+    writer.seek(0x20)

LMS/Common/Stream/Hashtable.py

@@ -0,0 +1,87 @@
+from LMS.FileIO.Stream import FileReader, FileWriter
+
+
+def read_labels(reader: FileReader) -> tuple[dict[int, str], int]:
+    labels = {}
+
+    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()
+            label = reader.read_string_len(length)
+            item_index = reader.read_uint32()
+            labels[item_index] = label
+
+        reader.seek(next_offset)
+
+    sorted_labels = {i: labels[i] for i in sorted(labels)}
+
+    # 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)
+
+
+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 = {}
+    index_map = {}
+    # Add each label to each hash slot
+    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]))
+            writer.write_uint32(label_offsets)
+            for label in hash_slots[i]:
+                label_offsets += len(label) + 5
+        else:
+            writer.write_uint32(0)
+            writer.write_uint32(label_offsets)
+
+    # Write the labels
+    for key in hash_slots:
+        stored_labels = hash_slots[key]
+        for label in stored_labels:
+            writer.write_uint8(len(label))
+            writer.write_string(label)
+            writer.write_uint32(index_map[label])
+
+
+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)
+    return (hash & 0xFFFFFFFF) % slot_count

LMS/Common/Stream/Section.py

@@ -0,0 +1,60 @@
+from typing import Any, Callable, Generator
+
+from LMS.FileIO.Stream import FileReader, FileWriter
+
+
+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)
+        size = reader.read_uint32()
+
+        # Skip to start of data
+        reader.skip(8)
+        end = reader.tell() + size
+
+        yield (magic, size)
+
+        # Seek past the AB padding on next iteration
+        reader.seek(end)
+        reader.align(16)
+
+
+def write_section(
+    writer: FileWriter,
+    magic: str,
+    section_call: Callable,
+    data: list[Any],
+    *write_parameters,
+) -> None:
+    writer.write_string(magic)
+    size_offset = writer.tell()
+
+    writer.write_uint32(0)
+    writer.write_bytes(b"\x00" * 8)
+    data_start = writer.tell()
+
+    section_call(writer, data, *write_parameters)
+
+    _write_end_data(writer, data_start, size_offset)
+
+
+def write_unsupported_section(writer: FileWriter, magic: str, data: bytes) -> None:
+    writer.write_string(magic)
+    size_offset = writer.tell()
+    writer.write_uint32(0)
+    writer.write_bytes(b"\x00" * 8)
+    data_start = writer.tell()
+    writer.write_bytes(data)
+    _write_end_data(writer, data_start, size_offset)
+
+
+def _write_end_data(writer: FileWriter, data_start: int, size_offset: int) -> None:
+    end = writer.tell()
+    size = end - data_start
+    writer.seek(size_offset)
+    writer.write_uint32(size)
+    writer.seek(end)
+    writer.write_alignment(b"\xAB", 16)

LMS/Config/Definitions/Attributes.py

@@ -0,0 +1,14 @@
+from dataclasses import dataclass, field
+
+from LMS.Config.Definitions.Value import ValueDefinition
+
+
+@dataclass(frozen=True)
+class AttributeConfig:
+    """Class that represents an attribute structure definition.
+
+    Configs may have multiple, linked to the if a game has multiple MSBP files."""
+
+    name: str
+    description: str = field(repr=False)
+    definitions: list[ValueDefinition]

LMS/Config/Definitions/Tags.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from LMS.Config.Definitions.Value import ValueDefinition
+
+
+@dataclass(frozen=True)
+class TagDefinition:
+    """Class that represents a signle tag definition in the structure."""
+
+    group_name: str
+    group_index: int
+    tag_name: str
+    tag_index: int
+    description: str
+    parameters: list[ValueDefinition] | None
+
+
+@dataclass(frozen=True)
+class TagConfig:
+    """Class that represents an tag structure definition."""
+
+    group_map: dict[int, str]
+    definitions: list[TagDefinition]
+
+    def get_definition_by_names(self, group: str, tag: str) -> TagDefinition:
+        group_index = None
+        for i, name in self.group_map.items():
+            if name == group:
+                group_index = i
+                break
+
+        if group_index is None:
+            raise KeyError(f"Group name '{group}' was not found! Is the group defined?")
+
+        for tag_def in self.definitions:
+            if tag_def.group_index == group_index and tag_def.tag_name == tag:
+                return tag_def
+
+        raise KeyError(
+            f"Tag name '{tag}' not found in group '{group}'. Os the tag defined?"
+        )
+
+    def get_definition_by_indexes(self, group: int, tag: int) -> TagDefinition:
+        for tag_def in self.definitions:
+            if tag_def.group_index == group and tag_def.tag_index == tag:
+                return tag_def
+
+        raise KeyError(
+            f"Tag index of {tag} was not found in group index {group}. Is the tag defined?"
+        )

LMS/Config/Definitions/Value.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+
+from LMS.Field.LMS_DataType import LMS_DataType
+
+
+@dataclass(frozen=True)
+class ValueDefinition:
+    name: str
+    description: str
+    datatype: LMS_DataType
+    list_items: dict[int, str]

LMS/Config/TitleConfig.py

@@ -0,0 +1,208 @@
+import importlib.resources as pkg_resources
+import os
+from typing import Self
+
+import yaml
+
+from LMS.Config.Definitions.Attributes import AttributeConfig
+from LMS.Config.Definitions.Tags import TagConfig, TagDefinition
+from LMS.Config.Definitions.Value import ValueDefinition
+from LMS.Field.LMS_DataType import LMS_DataType
+from LMS.Project.MSBP import MSBP
+
+
+class TitleConfig:
+    """Represents a configuration for a specific game/title."""
+
+    # Populate the preset list from the directory
+    PRESET_LIST = [
+        name.removesuffix(".yaml") for name in pkg_resources.contents("LMS.Config.Presets") if name.endswith(".yaml")
+    ]
+
+    def __init__(self, attribute_configs: dict[str, AttributeConfig], tag_config: TagConfig):
+        self._attribute_configs = attribute_configs
+        self._tag_config = tag_config
+
+    @property
+    def attribute_configs(self) -> dict[str, AttributeConfig]:
+        """The map of attribute config instances."""
+        return self._attribute_configs
+
+    @property
+    def tag_config(self) -> TagConfig:
+        """The loaded tag config instance."""
+        return self._tag_config
+
+    @classmethod
+    def load_preset(cls, game: str) -> Self:
+        """Loads an existing preset from the package."""
+        if game not in cls.PRESET_LIST:
+            raise FileNotFoundError(f"Preset '{game}' not found.")
+
+        with pkg_resources.open_text("LMS.Config.Presets", f"{game}.yaml") as f:
+            return cls.load_config(f.read())
+
+    @classmethod
+    def load_file(self, file_path: str) -> Self:
+        """Loads a config from a file.
+
+        :param file_path: the path to the config."""
+        with open(file_path, "r") as f:
+            return TitleConfig.load_config(f.read())
+
+    @classmethod
+    def load_config(cls, content: str | dict) -> Self:
+        """Loads the config of a specified game.
+
+        :param content: the config content, as a string or loaded as a dictionary."""
+        if isinstance(content, str):
+            parsed_content = yaml.safe_load(content)
+        else:
+            parsed_content = content
+
+        group_map = {0: "System"}
+        tag_config = []
+
+        # Add the System tag definitions to the config
+        with open(r"LMS\Message\Tag\System.yaml", "r") as f:
+            system_tags = yaml.safe_load(f)
+            tag_config = system_tags
+
+        # Combine with the rest of the cofnig
+        group_map |= parsed_content["tag_definitions"]["groups"]
+        for tag_def in parsed_content["tag_definitions"]["tags"]:
+            tag_config.append(tag_def)
+
+        # Load tag definitions
+        tag_definitions = []
+        for tag_def in tag_config:
+            tag_name = tag_def["name"]
+            group_index, tag_index = tag_def["group_index"], tag_def["tag_index"]
+            group_name = group_map[group_index]
+            tag_description = tag_def["description"]
+
+            group_name = group_map[group_index]
+
+            parameters = None
+            if "parameters" in tag_def:
+                parameters = []
+                for param_def in tag_def["parameters"]:
+                    param_name = param_def["name"]
+                    param_description = param_def["description"]
+                    datatype = LMS_DataType.from_string(param_def["datatype"])
+                    list_items = param_def.get("list_items")
+                    parameters.append(ValueDefinition(param_name, param_description, datatype, list_items))
+
+            tag_definitions.append(
+                TagDefinition(
+                    group_name,
+                    group_index,
+                    tag_name,
+                    tag_index,
+                    tag_description,
+                    parameters,
+                )
+            )
+
+        tag_config = TagConfig(group_map, tag_definitions)
+
+        # Load the attribute definitions
+        attribute_config = {}
+        for structure in parsed_content["attributes"]:
+            structure_name = structure["name"]
+
+            definitions = []
+            for info in structure["definitions"]:
+                name, description = info["name"], info["description"]
+                datatype = LMS_DataType.from_string(info["datatype"])
+                list_items = info.get("list_items")
+
+                definition = ValueDefinition(name, description, datatype, list_items)
+                definitions.append(definition)
+
+            structure = AttributeConfig(structure_name, structure["description"], definitions)
+            attribute_config[structure_name] = structure
+
+        return cls(attribute_config, tag_config)
+
+    @staticmethod
+    def generate_file(file_path: str, project: MSBP) -> None:
+        with open(file_path, "w+") as f:
+            yaml.safe_dump(
+                TitleConfig.generate_profile(project),
+                f,
+                default_flow_style=False,
+                sort_keys=False,
+            )
+
+    @staticmethod
+    def generate_config(project: MSBP) -> dict | None:
+        """Creates a message config file for the game.
+
+        :param project: a MSBP object."""
+        # TODO: Add custom node definitions
+
+        tag_key = "tag_definitions"
+        attr_key = "attributes"
+
+        config = {}
+        # Source files may be a path to a non-existent directory.
+        # These files were generated from the source machine from the actual libMS tool
+        # Shorten the filename with basname and replace the extension with .msbt for lookup later when reading a MSBT
+        config[tag_key] = {
+            "groups": {i + 1: group.name for i, group in enumerate(project.tag_groups[1:])},
+            "tags": [],
+        }
+
+        # Slice to exclude System group
+        for group_i, group in enumerate(project.tag_groups[1:], start=1):
+            for tag_i, info in enumerate(group.tag_definitions):
+
+                definition = {
+                    "name": info.name,
+                    "group_index": group_i,
+                    "tag_index": tag_i,
+                    "description": "",
+                    "parameters": [],
+                }
+
+                for param_info in info.param_info:
+                    param_definition = {
+                        "name": param_info.name,
+                        "description": "",
+                        "datatype": param_info.datatype.to_string(),
+                    }
+
+                    if param_info.datatype is LMS_DataType.LIST:
+                        param_definition["list_items"] = param_info.list_items
+
+                    definition["parameters"].append(param_definition)
+
+                config[tag_key]["tags"].append(definition)
+
+        # Set main attribute entries as the definitions from the MSBP
+        # Since most games use one MSBP these act the primary definitions
+        config[attr_key] = []
+
+        attr_definitions = []
+        for attr_info in project.attribute_info:
+            definition = {
+                "name": attr_info.name,
+                "description": "",
+                "datatype": attr_info.datatype.to_string(),
+            }
+            if attr_info.datatype is LMS_DataType.LIST:
+                definition["list_items"] = attr_info.list_items
+
+            attr_definitions.append(definition)
+
+        # Main attribute entries
+        config[attr_key].append(
+            {
+                "name": project.name,
+                "description": "",
+                "definitions": attr_definitions,
+            }
+        )
+
+        return config

LMS/Field/LMS_DataType.py

@@ -0,0 +1,83 @@
+from enum import Enum
+from typing import Literal, Type
+
+
+class LMS_DataType(Enum):
+
+    UINT8 = 0
+    UINT16 = 1
+    UINT32 = 2
+
+    INT8 = 3
+    INT16 = 4
+    INT32 = 5
+
+    FLOAT32 = 6
+
+    # Unknown 16 bit type (value of 6) has yet to be documented
+    ...
+
+    STRING = 8
+    LIST = 9
+
+    # Interface types
+    BOOL = "bool"
+    BYTE = "byte"
+
+    def to_string(self) -> str:
+        return self._name_.lower()
+
+    @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.BYTE,
+        ]:
+            return self in [LMS_DataType.INT8, LMS_DataType.INT16, LMS_DataType.INT32]
+
+        raise TypeError(f"Signed is not a valid property for '{self.to_string()}'!")
+
+    @property
+    def builtin_type(self) -> Type[int | str | float | 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.BYTE: bytes,
+        }[self]
+
+    @property
+    def stream_size(self) -> Literal[1, 2, 4]:
+        """The size the datatype takes up in a strema."""
+        return {
+            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,
+            LMS_DataType.LIST: 1,
+            LMS_DataType.BOOL: 1,
+            LMS_DataType.BYTE: 1,
+        }[self]
+
+    @classmethod
+    def from_string(cls, string: str):
+        """Creates a LMS_Datatype enum value from it's string representation"""
+        string = string.upper()
+        if string in cls.__members__:
+            return cls[string]
+        else:
+            raise ValueError(f"Unknown value of '{string}' was provided!")