PyLibMS 4.2.4__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

@@ -37,7 +37,9 @@ class LMS_FieldMap:
         return {field.name: field.value for field in self.fields.values()}
 
     @staticmethod
-    def create_default_dict_map(definitions: list[ValueDefinition]) -> dict[str, FieldValue]:
+    def create_default_dict_map(
+        definitions: list[ValueDefinition],
+    ) -> dict[str, FieldValue]:
         map = {}
         for definition in definitions:
             match definition.datatype:
@@ -101,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
@@ -145,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

lms/flowchart/definitions/node.py

@@ -21,15 +21,17 @@ NO_NEXT_NODE = -1
 
 class LMS_BaseNode:
     """
-    Class that represents common structure and methods for a LMS_Node.
+    Class that represents common structure and methods for any LMS_Node.
     """
 
-    def __init__(self,
-                 id: int | None,
-                 node_type: LMS_NodeType,
-                 parameter_type: LMS_NodeParameterType,
-                 parameter_value: LMS_NodeParameter | None):
-        self.id = id
+    def __init__(
+            self,
+            node_id: int,
+            node_type: LMS_NodeType,
+            parameter_type: LMS_NodeParameterType,
+            parameter_value: LMS_NodeParameter | None,
+    ):
+        self.id = node_id
         self._node_type = node_type
 
         self._parameter_type = parameter_type
@@ -68,13 +70,19 @@ class LMS_BaseNode:
     @parameter_value.setter
     def parameter_value(self, value: LMS_NodeParameter):
         if self._parameter_type == LMS_NodeParameterType.NONE:
-            raise TypeError("Unable to set parameter values when there is no parameter!")
+            raise TypeError(
+                "Unable to set parameter values when there is no parameter!"
+            )
 
         if isinstance(self._parameter_value, LMS_FieldMap):
-            raise ValueError("Edit a parameter value through the value property of a field!")
+            raise ValueError(
+                "Edit a parameter value through the value property of a field!"
+            )
 
         if not isinstance(value, self._parameter_type.builtin_type):
-            raise TypeError(f"Wrong value provided! Expected {self._parameter_type.builtin_type} got {type(value)}")
+            raise TypeError(
+                f"Wrong value provided! Expected {self._parameter_type.builtin_type} got {type(value)}"
+            )
 
         match self._parameter_type:
             case LMS_NodeParameterType.STRING:
@@ -84,15 +92,19 @@ class LMS_BaseNode:
                 self._parameter_value = value
             case _:
                 for i, parameter in enumerate(value):
-                    verify_number_from_datatype(parameter,
-                                                self._parameter_type.sliced_datatype[self._parameter_type][i])
+                    verify_number_from_datatype(
+                        parameter,
+                        self._parameter_type.sliced_datatype[self._parameter_type][i],
+                    )
 
         self._parameter_value = value
 
     def set_next_node(self, node: LMS_BaseNode | None) -> LMS_BaseNode | None:
-        """Set the next node for the instance.
+        """
+        Set the next node for the instance.
 
-        :param node: the node object, None for no next node."""
+        :param node: the node object, None for no next node.
+        """
         self._next_node = node
         return node
 
@@ -129,17 +141,18 @@ class LMS_BaseNode:
 
 class LMS_MessageNode(LMS_BaseNode):
     """
-    Class that represents a message node. Node utilized in juction with MSBT entries.
+    Class that represents a message node. Node utilized in junction with MSBT entries.
     """
 
-    def __init__(self,
-                 id: int | None,
-                 msbt_index: int,
-                 label_index: int,
-                 msbt: MSBT | None = None
-                 ):
+    def __init__(
+            self,
+            node_id: int,
+            msbt_index: int,
+            label_index: int,
+            msbt: MSBT | None = None,
+    ):
         super().__init__(
-            id,
+            node_id,
             LMS_NodeType.MESSAGE,
             LMS_NodeParameterType.NONE,
             None,
@@ -189,14 +202,16 @@ class LMS_BranchNode(LMS_BaseNode):
     Class that represents a branch node.
     """
 
-    def __init__(self,
-                 id: int,
-                 parameter_type: LMS_NodeParameterType,
-                 parameter_value: LMS_NodeParameter,
-                 condition_id: int,
-                 definition: NodeDefinition | None = None):
+    def __init__(
+            self,
+            node_id,
+            parameter_type: LMS_NodeParameterType,
+            parameter_value: LMS_NodeParameter,
+            condition_id: int,
+            definition: NodeDefinition | None = None,
+    ):
         super().__init__(
-            id,
+            node_id,
             LMS_NodeType.BRANCH,
             parameter_type,
             parameter_value,
@@ -212,14 +227,17 @@ class LMS_BranchNode(LMS_BaseNode):
         return f"{self._definition.name}({ {field.name: field.value for field in self._parameter_value} } {self.id}"
 
     def set_next_node(self, node: LMS_BaseNode | None) -> LMS_BaseNode | None:
-        raise NotImplementedError("Use function set_branch_case to alter the flow of a branch node!")
+        raise NotImplementedError(
+            "Use function set_branch_case to alter the flow of a branch node!"
+        )
 
     @classmethod
-    def new(cls,
+    def new(
+            cls,
             parameter_type: LMS_NodeParameterType,
             parameter_value: LMS_NodeParameter,
             condition_id: int,
-            ):
+    ):
         """
         Instantiates a new branch node.
 
@@ -230,18 +248,23 @@ class LMS_BranchNode(LMS_BaseNode):
         return cls(None, parameter_type, parameter_value, condition_id)
 
     @classmethod
-    def new_from_definition(cls,
-                            definition: NodeDefinition,
-                            **parameter_values: str | bool | float | bytes,
-                            ):
+    def new_from_definition(
+            cls,
+            definition: NodeDefinition,
+            **parameter_values: str | bool | float | bytes,
+    ):
         """
         Instantiates a new branch node from a definition.
 
         :param definition: the node definition.
         :param parameter_values: keyword arguments of parameters.
         """
-        converted = LMS_FieldMap.from_dict(parameter_values, definition.parameter_definitions)
-        return cls(None, definition.parameter_type, converted, definition.id)
+        converted = LMS_FieldMap.from_dict(
+            parameter_values, definition.parameter_definitions
+        )
+        return cls(
+            None, definition.parameter_type, converted, definition.id, definition
+        )
 
     @property
     def definition(self) -> NodeDefinition | None:
@@ -252,7 +275,9 @@ class LMS_BranchNode(LMS_BaseNode):
     def name(self) -> str:
         """Returns the name of the node. Must have provided a node configuration when reading the file."""
         if self._definition is None:
-            raise LMS_Error("Unable to access the name of the node without a definition set!")
+            raise LMS_Error(
+                "Unable to access the name of the node without a definition set!"
+            )
 
         return self._definition.name
 
@@ -271,12 +296,13 @@ class LMS_BranchNode(LMS_BaseNode):
         """The node branches."""
         return MappingProxyType(self._branches)
 
-    def get_case_options(self, compress_shared_references: bool = False) -> list[
-        tuple[tuple[int, ...], str, LMS_BaseNode | None]]:
+    def get_case_options(
+            self, compress_shared_references: bool = False
+    ) -> list[tuple[tuple[int, ...], str, LMS_BaseNode | None]]:
         """
         Retrieves the cases from this node formatted with the proper messages.
 
-        If a definition is provided, and either ``case_format`` or ``case_options`` are provied, the resulting
+        If a definition is provided, and either ``case_format`` or ``case_options`` are provided, the resulting
         message will utilize those values to format the message.
 
         :param compress_shared_references: whether to compress shared references into one case.
@@ -287,10 +313,11 @@ class LMS_BranchNode(LMS_BaseNode):
             case_map.setdefault(branch, []).append(case)
 
         if self.definition is not None:
-
             if self.definition.case_options:
                 for case, branch in self._branches.items():
-                    case_message = self.definition.case_options.get(case, f"Case {case}")
+                    case_message = self.definition.case_options.get(
+                        case, f"Case {case}"
+                    )
 
                     result.append(((case,), case_message, branch))
 
@@ -299,7 +326,9 @@ class LMS_BranchNode(LMS_BaseNode):
             if self.definition.case_format is not None:
                 if compress_shared_references:
                     for branch, cases in case_map.items():
-                        case_message = self._format_case_message(merge_shared_cases(cases))
+                        case_message = self._format_case_message(
+                            merge_shared_cases(cases)
+                        )
                         result.append((tuple(cases), case_message, branch))
                 else:
                     for case, branch in self._branches.items():
@@ -310,7 +339,11 @@ class LMS_BranchNode(LMS_BaseNode):
 
         if compress_shared_references:
             for branch, cases in case_map.items():
-                case_message = f"Case {cases[0]}" if len(cases) == 1 else f"Cases {merge_shared_cases(cases)}"
+                case_message = (
+                    f"Case {cases[0]}"
+                    if len(cases) == 1
+                    else f"Cases {merge_shared_cases(cases)}"
+                )
                 result.append((tuple(cases), case_message, branch))
         else:
             for case, branch in self._branches.items():
@@ -327,7 +360,8 @@ class LMS_BranchNode(LMS_BaseNode):
         string_map = {}
         for param_definition in self.definition.parameter_definitions:
             string_map[param_definition.name] = self.parameter_value[
-                param_definition.name].value
+                param_definition.name
+            ].value
 
         string_map["case"] = case_prefix
         return prefix.substitute(**string_map)
@@ -397,18 +431,15 @@ class LMS_EventNode(LMS_BaseNode):
     Class that represents an event node. Node utilized for in-game actions.
     """
 
-    def __init__(self,
-                 id: int,
-                 parameter_type: LMS_NodeParameterType,
-                 parameter_value: LMS_FieldMap | int | str | tuple[int, ...],
-                 event_id: int,
-                 definition: NodeDefinition | None = None,
-                 ):
-        super().__init__(
-            id,
-            LMS_NodeType.EVENT,
-            parameter_type,
-            parameter_value)
+    def __init__(
+            self,
+            node_id: int,
+            parameter_type: LMS_NodeParameterType,
+            parameter_value: LMS_FieldMap | int | str | tuple[int, ...],
+            event_id: int,
+            definition: NodeDefinition | None = None,
+    ):
+        super().__init__(node_id, LMS_NodeType.EVENT, parameter_type, parameter_value)
 
         self._event_id = event_id
         self._definition = definition
@@ -419,7 +450,12 @@ class LMS_EventNode(LMS_BaseNode):
         return f"{self._definition.name}({ {field.name: field.value for field in self._parameter_value} } {self.id}"
 
     @classmethod
-    def new(cls, parameter_type: LMS_NodeParameterType, parameter_value: int | str | tuple[int, ...], event_id: int):
+    def new(
+            cls,
+            parameter_type: LMS_NodeParameterType,
+            parameter_value: int | str | tuple[int, ...],
+            event_id: int,
+    ):
         """
         Instantiates a new event node.
 
@@ -432,18 +468,23 @@ class LMS_EventNode(LMS_BaseNode):
         return cls(None, parameter_type, parameter_value, event_id)
 
     @classmethod
-    def new_from_definition(cls,
-                            definition: NodeDefinition,
-                            **parameter_values: str | int | str | tuple[int, ...],
-                            ):
+    def new_from_definition(
+            cls,
+            definition: NodeDefinition,
+            **parameter_values: str | int | str | tuple[int, ...],
+    ):
         """
         Instantiates a new event node from a definition.
 
         :param definition: the node definition.
         :param parameter_values: keyword arguments of parameters.
         """
-        converted = LMS_FieldMap.from_dict(parameter_values, definition.parameter_definitions)
-        return cls(None, definition.parameter_type, converted, definition.id)
+        converted = LMS_FieldMap.from_dict(
+            parameter_values, definition.parameter_definitions
+        )
+        return cls(
+            None, definition.parameter_type, converted, definition.id, definition
+        )
 
     @property
     def definition(self) -> NodeDefinition | None:
@@ -469,12 +510,8 @@ class LMS_EntryNode(LMS_BaseNode):
     Class that represents an entry node. Node that is at the start of a flowchart.
     """
 
-    def __init__(self, id: int, flowchart_name: str = ""):
-        super().__init__(
-            id,
-            LMS_NodeType.ENTRY,
-            LMS_NodeParameterType.NONE,
-            None)
+    def __init__(self, node_id: int, flowchart_name: str = ""):
+        super().__init__(node_id, LMS_NodeType.ENTRY, LMS_NodeParameterType.NONE, None)
 
         self.flowchart_name = flowchart_name
 
@@ -484,14 +521,10 @@ class LMS_JumpNode(LMS_BaseNode):
     Class that represents a jump node. Node that jumps to another flowchart.
     """
 
-    def __init__(self, id: int, unknown_short0a: int):
-        super().__init__(
-            id,
-            LMS_NodeType.JUMP,
-            LMS_NodeParameterType.NONE,
-            None)
+    def __init__(self, node_id: int, unknown_short0a: int, next_entry_point: LMS_EntryNode = None):
+        super().__init__(node_id, LMS_NodeType.JUMP, LMS_NodeParameterType.NONE, None)
 
-        self.next_flowchart: LMS_EntryNode | None = None
+        self.next_flowchart = next_entry_point
 
         # TODO: Document this unknown value at 0xA in the node
         # This value is usually -1 in TL 3DS but is a set value in other games
@@ -505,17 +538,12 @@ class LMS_JumpNode(LMS_BaseNode):
         :param next_entry_point: the next entry point.
         :param unknown_short0a: unknown short value. -1 if there is no value.
         """
-        node = cls(None, unknown_short0a)
-        node.next_flowchart = next_entry_point
-        return node
+        return cls(None, unknown_short0a, next_entry_point)
 
     @property
-    def next_flowchart_id(self) -> int:
+    def next_flowchart_id(self) -> int | None:
         """The ID of the next flowchart."""
-        if self.next_flowchart is not None:
-            return self.next_flowchart.id
-
-        return self._stream_next_id
+        return None if self.next_flowchart is None else self.next_flowchart.id
 
     def set_next_node(self, node: LMS_BaseNode | None) -> LMS_BaseNode | None:
         super().set_next_node(node)
@@ -524,18 +552,24 @@ class LMS_JumpNode(LMS_BaseNode):
         return node
 
 
-def verify_parameter_structure(value: int | tuple[int, ...] | str, parameter_type: LMS_NodeParameterType) -> None:
+def verify_parameter_structure(
+        value: int | tuple[int, ...] | str, parameter_type: LMS_NodeParameterType
+) -> None:
     if parameter_type is LMS_NodeParameterType.NONE:
-        raise node_exceptions.LMS_NodeInvalidParameterTypeError("There must be a parameter type!")
+        raise node_exceptions.LMS_NodeInvalidParameterTypeError(
+            "There must be a parameter type!"
+        )
 
     if not isinstance(value, parameter_type.builtin_type):
         raise node_exceptions.LMS_NodeInvalidParameterValueError(
             f"Parameter type {parameter_type} expects type {parameter_type.builtin_type},"
-            f" but got {type(value)}.")
+            f" but got {type(value)}."
+        )
 
     if isinstance(value, tuple) and len(value) != parameter_type.value_count:
         raise node_exceptions.LMS_NodeMissingParameterValueError(
-            f"Parameter type {parameter_type} expects {parameter_type.value_count} parameter values, got {len(value)}!")
+            f"Parameter type {parameter_type} expects {parameter_type.value_count} parameter values, got {len(value)}!"
+        )
 
 
 def merge_shared_cases(cases: list[int]) -> str: