PyLibMS 4.2.3__py3-none-any.whl → 4.2.5__py3-none-any.whl

lms/common/field/io.py

@@ -1,15 +1,22 @@
 from typing import Callable
 
-from lms.common.field.lms_datatype import (LMS_DataType, is_bool_datatype,
-                                           is_bytes_datatype, is_list_datatype,
-                                           is_number_datatype)
+from lms.common.field.lms_datatype import (
+    LMS_DataType,
+    is_bool_datatype,
+    is_bytes_datatype,
+    is_list_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
 
 
-def read_field(reader: FileReader, definition: ValueDefinition,
-               read_variable_width_value: Callable | None = None) -> LMS_Field:
+def read_field(
+    reader: FileReader,
+    definition: ValueDefinition,
+    read_variable_width_value: Callable | None = None,
+) -> LMS_Field:
     # String is excluded as their reading varies between MSBT/MSBF
     match definition.datatype:
         case LMS_DataType.UINT8:
@@ -43,7 +50,11 @@ def read_field(reader: FileReader, definition: ValueDefinition,
     return LMS_Field(value, definition)  # type: ignore
 
 
-def write_field(writer: FileWriter, field: LMS_Field, write_variable_width_value: Callable | None = None) -> None:
+def write_field(
+    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] = {
             LMS_DataType.UINT8: writer.write_uint8,

lms/common/field/lms_datatype.py

@@ -119,9 +119,7 @@ class LMS_DataType(Enum):
         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.to_string()}'.")
 
     @classmethod
     def from_string(cls, string: str):
@@ -138,8 +136,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
@@ -150,7 +148,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

@@ -36,20 +36,28 @@ class LMS_FieldMap:
         """Converts the field map to a regular dictionary."""
         return {field.name: field.value for field in self.fields.values()}
 
-    @classmethod
-    def create_default_map(cls, definitions: list[ValueDefinition]):
-        field_map = {}
+    @staticmethod
+    def create_default_dict_map(
+        definitions: list[ValueDefinition],
+    ) -> dict[str, FieldValue]:
+        map = {}
         for definition in definitions:
             match definition.datatype:
+                case LMS_DataType.STRING:
+                    map[definition.name] = ""
                 case LMS_DataType.LIST:
-                    field_map[definition.name] = definition.list_items[0]
+                    map[definition.name] = definition.list_items[0]
                 case LMS_DataType.BOOL:
-                    field_map[definition.name] = False
+                    map[definition.name] = False
                 case LMS_DataType.FLOAT32:
-                    field_map[definition.name] = 0.0
+                    map[definition.name] = 0.0
                 case _:
-                    field_map[definition.name] = 0
-        return cls.from_dict(field_map, definitions)
+                    map[definition.name] = 0
+        return map
+
+    @classmethod
+    def create_default_map(cls, definitions: list[ValueDefinition]):
+        return cls.from_dict(LMS_FieldMap.create_default_map(definitions), definitions)
 
     @classmethod
     def from_dict(cls, data: dict[str, FieldValue], definitions: list[ValueDefinition]):
@@ -95,7 +103,9 @@ class LMS_Field:
     """
 
     def __init__(
-            self, value: int | str | float | bytes | bool, definition: ValueDefinition,
+        self,
+        value: int | str | float | bytes | bool,
+        definition: ValueDefinition,
     ):
         _verify_value_from_definition(value, definition)
         self._definition = definition
@@ -139,7 +149,7 @@ class LMS_Field:
 
 
 def _verify_value_from_definition(
-        value: int | str | float | bytes | bool, definition: ValueDefinition
+    value: int | str | float | bytes | bool, definition: ValueDefinition
 ) -> None:
     datatype = definition.datatype
 

lms/common/lms_constants.py

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

lms/common/stream/fileinfo.py

@@ -1,5 +1,10 @@
 from lms.common import lms_exceptions
-from lms.common.lms_constants import BIG_ENDIAN_BOM, SECTION_DATA_START, LITTLE_ENDIAN_BOM, SIZE_OFFSET
+from lms.common.lms_constants import (
+    BIG_ENDIAN_BOM,
+    SECTION_DATA_START,
+    LITTLE_ENDIAN_BOM,
+    SIZE_OFFSET,
+)
 from lms.common.lms_fileinfo import LMS_FileInfo
 from lms.fileio.encoding import FileEncoding
 from lms.fileio.io import FileReader, FileWriter
@@ -25,7 +30,9 @@ def read_file_info(reader: FileReader, expected_magic: str) -> LMS_FileInfo:
     version = reader.read_uint8()
 
     if version < 3:
-        raise lms_exceptions.LMS_UnsupportedFileVersionError("Only version 3+ files are supported!")
+        raise lms_exceptions.LMS_UnsupportedFileVersionError(
+            "Only version 3+ files are supported!"
+        )
 
     section_count = reader.read_uint16()
 
@@ -34,7 +41,9 @@ def read_file_info(reader: FileReader, expected_magic: str) -> LMS_FileInfo:
 
     reader.seek(0, 2)
     if file_size != (real_size := reader.tell()):
-        raise lms_exceptions.LMS_MisalignedSizeError(f"File size is misaligned!` Got {file_size} expected {real_size}.")
+        raise lms_exceptions.LMS_MisalignedSizeError(
+            f"File size is misaligned!` Got {file_size} expected {real_size}."
+        )
 
     reader.seek(SECTION_DATA_START)
 

lms/common/stream/hashtable.py

@@ -27,7 +27,12 @@ def read_labels(reader: FileReader) -> tuple[dict, int]:
     return sorted_labels, slot_count
 
 
-def write_labels(writer: FileWriter, labels: list[str], slot_count: int, index_map: dict[str, int] = None) -> None:
+def write_labels(
+    writer: FileWriter,
+    labels: list[str],
+    slot_count: int,
+    index_map: dict[str, int] = None,
+) -> None:
     writer.write_uint32(slot_count)
 
     hash_slots = {}

lms/common/stream/section.py

@@ -2,12 +2,12 @@ from typing import Any, Callable, Generator
 
 from lms.fileio.io import FileReader, FileWriter
 
-SECTION_PADDING_BYTE = b"\xAB"
+SECTION_PADDING_BYTE = b"\xab"
 SECTION_ALIGNMENT = 16
 
 
 def read_section_data(
-        reader: FileReader, section_count: int
+    reader: FileReader, section_count: int
 ) -> Generator[tuple[str, int], Any, None]:
     reader.seek(0x20)
     for _ in range(section_count):
@@ -24,11 +24,11 @@ def read_section_data(
 
 
 def write_section(
-        writer: FileWriter,
-        magic: str,
-        section_call: Callable,
-        data: list[Any],
-        *write_arguments: Any,
+    writer: FileWriter,
+    magic: str,
+    section_call: Callable,
+    data: list[Any],
+    *write_arguments: Any,
 ) -> None:
     writer.write_string(magic)
     size_offset = writer.tell()

lms/fileio/encoding.py

@@ -10,7 +10,7 @@ class FileEncoding(IntEnum):
     UTF32 = 0x02
 
     def to_string_format(
-            self, is_big_endian: bool = False
+        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:

lms/fileio/io.py

@@ -106,7 +106,7 @@ class FileReader:
     def read_encoded_string(self):
         message = b""
         while (
-                raw_char := self.read_bytes(self.encoding.width)
+            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))

lms/flowchart/definitions/flowchart.py

@@ -7,7 +7,9 @@ from lms.flowchart.definitions.node import LMS_EntryNode, LMS_BranchNode, LMS_Ba
 class LMS_Flowchart:
     """Class that represents a flowchart in a MSBF file."""
 
-    def __init__(self, entry_point: LMS_EntryNode, id_generator: Callable[[], int]) -> None:
+    def __init__(
+            self, entry_point: LMS_EntryNode, id_generator: Callable[[], int]
+    ) -> None:
         self._entry_node = entry_point
         self._nodes: dict[int, LMS_BaseNode] = {}
         self._id_generator = id_generator
@@ -16,7 +18,6 @@ class LMS_Flowchart:
             for node in entry_point.get_descendents():
                 self._nodes[node.id] = node
 
-
     def __iter__(self) -> Iterator[LMS_BaseNode]:
         return iter(self._nodes.values())
 
@@ -28,7 +29,7 @@ class LMS_Flowchart:
 
     @property
     def name(self) -> str:
-        """The name of the flowchart. """
+        """The name of the flowchart."""
         return self._entry_node.flowchart_name
 
     @name.setter
@@ -41,7 +42,7 @@ class LMS_Flowchart:
         return self._entry_node
 
     @property
-    def nodes(self) -> MappingProxyType[LMS_BaseNode]:
+    def nodes(self) -> MappingProxyType[int, LMS_BaseNode]:
         """All nodes in the flowchart instance."""
         return MappingProxyType(self._nodes)
 
@@ -52,10 +53,14 @@ class LMS_Flowchart:
         :param node: the node to add.
         """
         if not isinstance(node, LMS_BaseNode):
-            raise TypeError(f"Node type '{type(node).__name__}' is not a child of LMS_BaseNode!")
+            raise TypeError(
+                f"Node type '{type(node).__name__}' is not a child of LMS_BaseNode!"
+            )
 
         if node in self._nodes.values():
-            raise ValueError(f"Node of ID '{node.id}' is already registered to this flowchart!")
+            raise ValueError(
+                f"Node of ID '{node.id}' is already registered to this flowchart!"
+            )
 
         node.id = self._id_generator()
         self._nodes[node.id] = node