PyLibMS 3.1.7__tar.gz → 3.2.0__tar.gz

{pylibms-3.1.7 → pylibms-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyLibMS
-Version: 3.1.7
+Version: 3.2.0
 Summary: Python library built for the libMessageStudio (LMS) proprietary file formats from Nintendo. Supports MSBT, MSBP, and MSBF.
 Author: AbdyyEee
 License: Copyright 2025 AbdyyEee

{pylibms-3.1.7 → pylibms-3.2.0}/PyLibMS.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyLibMS
-Version: 3.1.7
+Version: 3.2.0
 Summary: Python library built for the libMessageStudio (LMS) proprietary file formats from Nintendo. Supports MSBT, MSBP, and MSBF.
 Author: AbdyyEee
 License: Copyright 2025 AbdyyEee

{pylibms-3.1.7 → pylibms-3.2.0}/lms/common/lms_datatype.py

@@ -1,5 +1,35 @@
+from __future__ import annotations
+
 from enum import Enum
-from typing import Type
+from typing import Type, TypeGuard
+
+
+def is_number_datatype(value: object, datatype: LMS_DataType) -> TypeGuard[int | float]:
+    return datatype in (
+        LMS_DataType.UINT8,
+        LMS_DataType.UINT16,
+        LMS_DataType.UINT32,
+        LMS_DataType.INT8,
+        LMS_DataType.INT16,
+        LMS_DataType.INT32,
+        LMS_DataType.FLOAT32,
+    ) and isinstance(value, (int, float))
+
+
+def is_list_datatype(value: object, datatype: LMS_DataType) -> TypeGuard[str]:
+    return datatype is LMS_DataType.LIST and isinstance(value, str)
+
+
+def is_bool_datatype(value: object, datatype: LMS_DataType) -> TypeGuard[bool]:
+    return datatype is LMS_DataType.BOOL and isinstance(value, bool)
+
+
+def is_bytes_datatype(value: object, datatype: LMS_DataType) -> TypeGuard[bytes]:
+    return datatype is LMS_DataType.BYTES and isinstance(value, bytes)
+
+
+def is_string_datatype(value: object, datatype: LMS_DataType) -> TypeGuard[str]:
+    return datatype is LMS_DataType.STRING and isinstance(value, str)
 
 
 class LMS_DataType(Enum):
@@ -17,16 +47,16 @@ class LMS_DataType(Enum):
 
     # Unknown 16 bit type (value of 6) has yet to be documented
     # Might be some sort of 2 byte integer, float, or may be an array.
-    # We wont ever know cause no game (yet that has been found) has utilized this type
+    # We won't ever know cause no game (yet that has been found) has utilized this type
     # Thanks Nintendo.
     ...
 
     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.
+    # Interface types
+    # These types act as an abstraction for a real LMS_Datatype
+    # The actual value isn't important since they are not real types, but are instantiated from a config
     BOOL = "bool"
     BYTES = "byte"
 
@@ -81,7 +111,7 @@ class LMS_DataType(Enum):
 
     @classmethod
     def from_string(cls, string: str):
-        """Creates a LMS_Datatype enum value from it's string representation"""
+        """Creates an enum value from its string representation"""
         member = string.upper()
         if member in cls.__members__:
             return cls[member]

{pylibms-3.1.7 → pylibms-3.2.0}/lms/fileio/io.py

@@ -93,7 +93,7 @@ class FileReader:
     def read_string_len(self, length: int) -> str:
         return self._stream.read(length).decode("UTF-8")
 
-    def read_str_variable_encoding(self):
+    def read_encoded_string(self):
         message = b""
         while (
             raw_char := self.read_bytes(self.encoding.width)
@@ -101,7 +101,7 @@ class FileReader:
             message += raw_char
         return message.decode(self.encoding.to_string_format(self.is_big_endian))
 
-    def read_len_string_variable_encoding(self):
+    def read_len_string_encoded(self):
         self.align(self.encoding.width)
         length = self.read_uint16()
         return self.read_bytes(length).decode(
@@ -138,7 +138,7 @@ class FileWriter:
         return self.data.tell()
 
     def write_alignment(self, data: bytes, alignment: int) -> None:
-        self.write_bytes(data * self.align(self.tell(), alignment))
+        self.write_bytes(data * self._align(self.tell(), alignment))
 
     def write_uint16_array(self, array: list[int]) -> None:
         for number in array:
@@ -168,18 +168,18 @@ class FileWriter:
     def write_string(self, string: str):
         self.write_bytes(string.encode("UTF-8"))
 
-    def write_len_variable_encoding_string(self, string: str) -> None:
+    def write_len_encoded_string(self, string: str) -> None:
         self.write_uint16(len(string) * self.encoding.width)
-        self.write_variable_encoding_string(string, False)
+        self.write_encoded_string(string, False)
 
-    def write_variable_encoding_string(self, string: str, terminate: bool = True):
+    def write_encoded_string(self, string: str, terminate: bool = True):
         self.write_bytes(
             string.encode(self.encoding.to_string_format(self.is_big_endian))
         )
         if terminate:
             self.write_bytes(b"\x00" * self.encoding.width)
 
-    def align(self, number: int, alignment: int) -> int:
+    def _align(self, number: int, alignment: int) -> int:
         return (-number % alignment + alignment) % alignment
 
     def _get_datatype(self, name: str) -> str:

pylibms-3.2.0/lms/message/definitions/field/io.py

@@ -0,0 +1,60 @@
+from typing import Callable
+
+from lms.common.lms_datatype import (LMS_DataType, is_bool_datatype,
+                                     is_bytes_datatype, is_list_datatype,
+                                     is_number_datatype)
+from lms.fileio.io import FileReader, FileWriter
+from lms.message.definitions.field.lms_field import LMS_Field
+from lms.titleconfig.definitions.value import ValueDefinition
+
+
+def read_field(reader: FileReader, definition: ValueDefinition) -> LMS_Field:
+    # String is excluded as their reading varies between tags and attributes
+    match definition.datatype:
+        case LMS_DataType.UINT8:
+            value = reader.read_uint8()
+        case LMS_DataType.UINT16:
+            value = reader.read_uint16()
+        case LMS_DataType.UINT32:
+            value = reader.read_uint32()
+        case LMS_DataType.INT8:
+            value = reader.read_int8()
+        case LMS_DataType.INT16:
+            value = reader.read_int16()
+        case LMS_DataType.INT32:
+            value = reader.read_int32()
+        case LMS_DataType.FLOAT32:
+            value = reader.read_float32()
+        case LMS_DataType.LIST:
+            index = reader.read_uint8()
+            value = definition.list_items[index]
+        case LMS_DataType.BOOL:
+            value = bool(reader.read_uint8())
+        case LMS_DataType.BYTES:
+            value = reader.read_bytes(1)
+
+    return LMS_Field(value, definition)  # type: ignore
+
+
+def write_field(writer: FileWriter, field: LMS_Field) -> None:
+    if is_number_datatype(field.value, field.datatype):
+        write_functions: dict[LMS_DataType, Callable] = {
+            LMS_DataType.UINT8: writer.write_uint8,
+            LMS_DataType.INT8: writer.write_int8,
+            LMS_DataType.UINT16: writer.write_uint16,
+            LMS_DataType.INT16: writer.write_int16,
+            LMS_DataType.UINT32: writer.write_uint32,
+            LMS_DataType.INT32: writer.write_int32,
+            LMS_DataType.FLOAT32: writer.write_float32,
+        }
+        write_functions[field.datatype](field.value)
+        return
+
+    if is_list_datatype(field.value, field.datatype):
+        writer.write_uint8(field.list_items.index(field.value))
+    elif is_bytes_datatype(field.value, field.datatype):
+        writer.write_bytes(field.value)
+    elif is_bool_datatype(field.value, field.datatype):
+        writer.write_uint8(bool(field.value))
+    else:
+        raise ValueError(f"Unsupported datatype: {field.datatype}")

{pylibms-3.1.7 → pylibms-3.2.0}/lms/message/definitions/field/lms_field.py

@@ -1,8 +1,7 @@
 from __future__ import annotations
 
 from collections.abc import Iterator
-from dataclasses import dataclass, field
-from typing import cast
+from dataclasses import dataclass
 
 from lms.common.lms_datatype import LMS_DataType
 from lms.titleconfig.definitions.value import ValueDefinition
@@ -17,7 +16,8 @@ type FieldValue = int | str | float | bool | bytes
 @dataclass(frozen=True)
 class LMS_FieldMap:
     """
-    A wrapper for a dictionary of LMS_Field objects for controlled access, validation and abstraction from the dictionary object.
+    A wrapper for a dictionary of LMS_Field objects for controlled access, validation
+    and abstraction from the dict object.
     """
 
     fields: dict[str, LMS_Field]
@@ -91,8 +91,8 @@ class LMS_Field:
 
     def __repr__(self):
         if self.datatype is LMS_DataType.LIST:
-            return f"LMS_Field(value={self._value}, list_items={self.list_items})"
-        return f"LMS_Field(value={self._value}, type={self.datatype.name})"
+            return f"LMS_Field(value={self._value!r}, list_items={self.list_items!r})"
+        return f"LMS_Field(value={self._value!r}, type={self.datatype!r})"
 
     @property
     def name(self) -> str:
@@ -147,7 +147,7 @@ def _verify_value(
             else:
                 return
         case LMS_DataType.FLOAT32 if isinstance(value, float):
-            _verify_range(value, FLOAT_MIN, FLOAT_MAX, definition)
+            _verify_number_is_in_range(value, FLOAT_MIN, FLOAT_MAX, definition)
             return
         case _ if isinstance(value, int):
             bits = datatype.stream_size * 8
@@ -157,7 +157,7 @@ def _verify_value(
             else:
                 min_value, max_value = 0, (2**bits) - 1
 
-            _verify_range(value, min_value, max_value, definition)
+            _verify_number_is_in_range(value, min_value, max_value, definition)
             return
 
     raise TypeError(
@@ -165,10 +165,13 @@ def _verify_value(
     )
 
 
-def _verify_range(
-    value: int | float, min: int | float, max: int | float, definition: ValueDefinition
+def _verify_number_is_in_range(
+    value: int | float,
+    min_value: int | float,
+    max_value: int | float,
+    definition: ValueDefinition,
 ):
-    if not min <= value <= max:
+    if not min_value <= value <= max_value:
         raise ValueError(
-            f"The value '{value}' of type '{definition.datatype}' provided for field '{definition.name}' is out of range of ({min}, {max})"
+            f"The value '{value}' of type '{definition.datatype}' provided for field '{definition.name}' is out of range of ({min_value}, {max_value})"
         )

{pylibms-3.1.7 → pylibms-3.2.0}/lms/message/definitions/lms_messagetext.py

@@ -9,7 +9,7 @@ from lms.titleconfig.config import TagConfig
 class LMS_MessageText:
     """Class that represents a message text entry."""
 
-    TAG_FORMAT = re.compile(r"(\[[^\]]+\])")
+    TAG_FORMAT = re.compile(r"(\[[^]]+])")
 
     def __init__(
         self,
@@ -38,7 +38,7 @@ class LMS_MessageText:
         return "".join(result)
 
     @text.setter
-    def text(self, string: str):
+    def text(self, string: str) -> None:
         self._set_parts(string)
 
     @property
@@ -47,19 +47,20 @@ class LMS_MessageText:
         return [part for part in self._parts if is_tag(part)]
 
     def append_encoded_tag(
-        self, group_id: int, tag_index: int, is_closing: bool = False, *parameters: str
+        self, group_id: int, tag_index: int, *parameters: str, is_closing: bool = False
     ) -> 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:
-        :param parameters: a list of hex strings.
+        :param group_id: the group index.
+        :param tag_index: the index of the tag in the group.
+        :param parameters: args of hex strings.
+        :param is_closing: whether the tag is closing or not.
 
-        ## Usage
-        ```
-        message.append_encoded_tag(1, 2, "01", "00", "00", "CD")
-        ```
+        Example
+        ------
+        >>> message = LMS_MessageText("Text")
+        >>> message.append_encoded_tag(0, 3, "00", "23", "43", "32")
         """
         if is_closing:
             tag = LMS_EncodedTag(group_id, tag_index, is_closing=True)
@@ -79,35 +80,32 @@ class LMS_MessageText:
         **parameters: int | str | float | bool | bytes,
     ) -> LMS_DecodedTag:
         """
-        Appends an decoded tag to the current message and returns that tag.
+        Appends a decoded tag to the current message and returns that tag.
 
         :param group_name: the group name.
         :param tag_name: the tag name.:
+        :param is_closing: whether the tag is closing or not.
         :param parameters: keyword arguments of parameters mapped to their value.
 
-        ## Usage
-        ```
-        message.append_decoded_tag("Mii", "Nickname", buffer=1, type="Voice", conversion="None")
-        ```
+        Example
+        -------
+        >>> message = LMS_MessageText("Text")
+        >>> message.append_decoded_tag("Mii", "Nickname", buffer=1, type="Voice", conversion="None")
         """
         if self._tag_config is None:
             raise ValueError("A TitleConfig is required to append decoded tags.")
 
         definition = self._tag_config.get_definition_by_names(group_name, tag_name)
 
-        param_map = None
-
         if not parameters:
             tag = LMS_DecodedTag(definition)
-            self._parts.append(tag)
-            return tag
-
-        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)
+            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

{pylibms-3.1.7 → pylibms-3.2.0}/lms/message/msbt.py

@@ -1,21 +1,29 @@
 from typing import Any
 
 from lms.common.lms_fileinfo import LMS_FileInfo
-from lms.message.definitions.field.lms_field import FieldValue, LMS_FieldMap
-from lms.message.definitions.lms_messagetext import LMS_MessageText
 from lms.message.msbtentry import MSBTEntry
 from lms.titleconfig.definitions.attribute import AttributeConfig
 from lms.titleconfig.definitions.tags import TagConfig
 
 
 class MSBT:
-    """A class that represents a MSBT file.
+    """
+    A class that represents a MSBT file.
 
-    https://nintendo-formats.com/libs/lms/msbt.html."""
+    https://nintendo-formats.com/libs/lms/msbt.html.
+    """
+
+    MAGIC = "MsgStdBn"
+
+    # While 101 is the default slot count for LBL1 sections in a MSBT
+    # The value may be overridden at the instance level as some games alter the value
+    DEFAULT_SLOT_COUNT = 101
 
     def __init__(
         self,
         info: LMS_FileInfo | None = None,
+        section_list: list[str] | None = None,
+        _unsupported_section_map: dict[str, bytes] | None = None,
         attribute_config: AttributeConfig | None = None,
         tag_config: TagConfig | None = None,
     ):
@@ -26,17 +34,15 @@ class MSBT:
 
         self.size_per_attribute = 0
 
-        # 101 is default for almost all games. However the value can be overriden by some games (i.e Echos of Wisdom).
-        # Due to this, the slot count is set dynamically when LBL1 is read.
-        self.slot_count = 101
+        self.slot_count = MSBT.DEFAULT_SLOT_COUNT
 
-        self.attr_string_table: bytes | None = None
         self.uses_encoded_attributes = True
+        self.attr_string_table: bytes | None = None
 
-        self.unsupported_sections: dict[str, bytes] = {}
+        self._unsupported_section_map = _unsupported_section_map or {}
 
         # Store the section list so that the order of any and all sections is preserved when writing
-        self._section_list: list[str] = ["LBL1"]
+        self._section_list: list[str] = section_list or ["LBL1"]
 
         self._attribute_config = attribute_config
         self._tag_config = tag_config
@@ -54,9 +60,14 @@ class MSBT:
         """The list of sections with order preserved."""
         return tuple(self._section_list)
 
+    @property
+    def unsupported_sections(self) -> tuple[str, ...]:
+        """The list of unsupported sections."""
+        return tuple(self._unsupported_section_map.keys())
+
     @property
     def has_attributes(self) -> bool:
-        """If the msbt contains attributs."""
+        """If the msbt contains attributes."""
         return self.section_exists("ATR1")
 
     @property
@@ -79,7 +90,7 @@ class MSBT:
         """
         Retrieves an entry given its name.
 
-        :param name: the label name for the entry.
+        :param label: the label name for the entry.
         """
         if label not in self._label_map:
             raise KeyError(f"The label '{label}' does not exist!")
@@ -139,3 +150,14 @@ class MSBT:
         :param name: the name of the section.
         """
         return name in self._section_list
+
+    def get_unsupported_section_data(self, name: str) -> bytes:
+        """
+        Retrieves the raw data of an unsupported section.
+
+        :param name: the name of the section.
+        """
+        if name not in self._unsupported_section_map:
+            raise KeyError(f"The section '{name}' does not exist in the MSBT!")
+
+        return self._unsupported_section_map[name]

{pylibms-3.1.7 → pylibms-3.2.0}/lms/message/msbtentry.py

@@ -29,7 +29,8 @@ class MSBTEntry:
 
         if attribute is not None and not isinstance(attribute, (LMS_FieldMap, bytes)):
             raise TypeError(
-                f"An invalid type was provided for attribute in entry '{name}'. Expected dict or bytes got {type(attribute)},"
+                f"An invalid type was provided for attribute in entry '{name}'. "
+                f"Expected LMS_FieldMap or bytes, got {type(attribute)}"
             )
 
         self._attribute = attribute
@@ -47,9 +48,10 @@ class MSBTEntry:
 
     def to_dict(self) -> dict:
         """Converts the MSBTEntry instance into a dictionary object."""
-        result = {}
-        result["name"] = self.name
-        result["message"] = "" if self.message is None else self.message.text
+        result: dict[str, int | str | dict | None] = {
+            "name": self.name,
+            "message": "" if self.message is None else self.message.text,
+        }
 
         if self._attribute is not None:
             if isinstance(self._attribute, bytes):
@@ -64,7 +66,7 @@ class MSBTEntry:
     def from_dict(
         cls,
         data: dict,
-        attribute_conifg: AttributeConfig | None = None,
+        attribute_config: AttributeConfig | None = None,
         tag_config: TagConfig | None = None,
     ):
         """
@@ -86,12 +88,12 @@ class MSBTEntry:
                 raise TypeError("Invalid attribute type provided!")
 
             if isinstance(attribute, dict):
-                if attribute_conifg is None:
+                if attribute_config is None:
                     raise TypeError(
                         "A valid attribute config must be provided for decoded attributes!"
                     )
                 attribute = LMS_FieldMap.from_dict(
-                    attribute, attribute_conifg.definitions
+                    attribute, attribute_config.definitions
                 )
             else:
                 attribute = bytes.fromhex(attribute)

{pylibms-3.1.7 → pylibms-3.2.0}/lms/message/msbtio.py

@@ -26,16 +26,14 @@ def read_msbt_path(
     """
     Reads and retrieves a MSBT file from a given path.
 
-    :param stream: a stream object.
+    :param file_path: the path to the MSBT file.
     :param attribute_config: the attribute config to use for decoding attributes.
     :param tag_config: the tag config to use for decoding tags.
     :param suppress_tag_errors: when a tag config is used, suppress any errors while reading decoded tags.
 
-    ## Usage
-    ```
-    msbt: MSBT = read_msbt_path("path/to/file.msbt")
-    ...
-    ```
+    Example
+    ---------
+    >>> msbt = read_msbt_path("path/to/file.msbt")
     """
     with open(file_path, "rb") as stream:
         return read_msbt(
@@ -56,44 +54,50 @@ def read_msbt(
     """
     Reads and retrieves a MSBT file from a specified stream.
 
-    :param stream: an `IOBase`, `BytesIO`, `memoryview`, or `bytes` object.
+    :param stream: an ``IOBase``, ``BytesIO``, ``memoryview``, or ``bytes`` object.
     :param attribute_config: the attribute config to use for decoding attributes.
     :param tag_config: the tag config to use for decoding tags.
     :param suppress_tag_errors: when a tag config is used, suppress any errors while reading decoded tags.
 
-    ## Usage
-    ```
-    msbt: MSBT = read_msbt(stream)
-    ...
-    ```
+    Example
+    ---------
+    >>> msbt = read_msbt(stream)
     """
     reader = FileReader(stream)
-    file_info = read_file_info(reader, "MsgStdBn")
+    file_info = read_file_info(reader, MSBT.MAGIC)
 
-    file = MSBT(file_info, attribute_config, tag_config)
+    section_list = []
+    unsupported_sections = {}
+    slot_count = MSBT.DEFAULT_SLOT_COUNT
 
-    if attribute_config is not None:
-        file.uses_encoded_attributes = False
+    messages = atr1_data = style_indexes = None
 
-    atr1_data = style_indexes = None
+    labels: dict[int, str] = {}
     for magic, size in read_section_data(reader, file_info.section_count):
         match magic:
             case "LBL1":
                 labels, slot_count = read_labels(reader)
-                file.slot_count = slot_count
             case "ATR1":
                 atr1_data = read_atr1(reader, attribute_config, size)
-                file.size_per_attribute = atr1_data.size_per_attribute
-                file.attr_string_table = atr1_data.string_table
             case "TXT2":
                 messages = read_txt2(reader, tag_config, suppress_tag_errors)
             case "TSY1":
                 style_indexes = read_tsy1(reader, len(labels))
             case _:
-                file.unsupported_sections[magic] = reader.read_bytes(size)
+                unsupported_sections[magic] = reader.read_bytes(size)
 
-        if not file.section_exists(magic):
-            file._section_list.append(magic)
+        if magic not in section_list:
+            section_list.append(magic)
+
+    file = MSBT(
+        file_info, section_list, unsupported_sections, attribute_config, tag_config
+    )
+    file.slot_count = slot_count
+
+    file.uses_encoded_attributes = attribute_config is None
+    if atr1_data is not None:
+        file.size_per_attribute = atr1_data.size_per_attribute
+        file.attr_string_table = atr1_data.string_table
 
     for i, label in labels.items():
         text = None if messages is None else messages[i]
@@ -111,13 +115,11 @@ def write_msbt_path(file_path: str, file: MSBT) -> None:
     Writes a MSBT file to a given file path.
 
     :param file_path: the path to write the file to.
-    :param msbt: the MSBT file object.
+    :param file: the MSBT file object.
 
-    ## Usage
-    ```
-    write_msbt_path("path/to/file.msbt", msbt)
-    ...
-    ```
+    Example
+    -------
+    >>> write_msbt_path("path/to/file.msbt", msbt)
     """
     with open(file_path, "wb") as stream:
         data = write_msbt(file)
@@ -129,10 +131,9 @@ def write_msbt(file: MSBT) -> bytes:
 
     :param file: a MSBT object.
 
-    ## Usage
-    ```
-    data = write_msbt(msbt)
-    ```
+    Example
+    -------
+    >>> data = write_msbt(msbt)
     """
     if not isinstance(file, MSBT):
         raise LMS_Exceptions.LMS_Error(
@@ -140,7 +141,7 @@ def write_msbt(file: MSBT) -> bytes:
         )
 
     writer = FileWriter(file.info.encoding)
-    write_file_info(writer, "MsgStdBn", file.info)
+    write_file_info(writer, MSBT.MAGIC, file.info)
 
     for section in file.section_list:
         match section:
@@ -174,7 +175,7 @@ def write_msbt(file: MSBT) -> bytes:
                 write_section(writer, "TSY1", write_tsy1, style_indexes)
             case _:
                 write_unsupported_section(
-                    writer, section, file.unsupported_sections[section]
+                    writer, section, file.get_unsupported_section_data(section)
                 )
 
     writer.seek(0x12)

{pylibms-3.1.7 → pylibms-3.2.0}/lms/message/section/atr1.py

@@ -3,8 +3,11 @@ from dataclasses import dataclass
 from lms.common.lms_datatype import LMS_DataType
 from lms.fileio.io import FileReader, FileWriter
 from lms.message.definitions.field.io import read_field, write_field
-from lms.message.definitions.field.lms_field import (LMS_DataType, LMS_Field,
-                                                     LMS_FieldMap)
+from lms.message.definitions.field.lms_field import (
+    LMS_DataType,
+    LMS_Field,
+    LMS_FieldMap,
+)
 from lms.titleconfig.definitions.attribute import AttributeConfig
 
 
@@ -54,7 +57,7 @@ def read_decoded_atr1(reader: FileReader, config: AttributeConfig) -> ATR1Data:
             if definition.datatype is LMS_DataType.STRING:
                 last = reader.tell() + 4
                 reader.seek(section_start + reader.read_uint32())
-                value = LMS_Field(reader.read_str_variable_encoding(), definition)
+                value = LMS_Field(reader.read_encoded_string(), definition)
                 reader.seek(last)
             else:
                 value = read_field(reader, definition)
@@ -109,4 +112,4 @@ def write_decoded_atr1(
                 write_field(writer, field)
 
     for string in string_table:
-        writer.write_variable_encoding_string(string)
+        writer.write_encoded_string(string)