eolib 1.1.1__py3-none-any.whl → 2.0.0__py3-none-any.whl

eolib/protocol/_generated/pub/ecf_record.py

@@ -12,16 +12,42 @@ class EcfRecord:
     Record of Class data in an Endless Class File
     """
     _byte_size: int = 0
-    _name_length: int = None # type: ignore [assignment]
-    _name: str = None # type: ignore [assignment]
-    _parent_type: int = None # type: ignore [assignment]
-    _stat_group: int = None # type: ignore [assignment]
-    _str: int = None # type: ignore [assignment]
-    _intl: int = None # type: ignore [assignment]
-    _wis: int = None # type: ignore [assignment]
-    _agi: int = None # type: ignore [assignment]
-    _con: int = None # type: ignore [assignment]
-    _cha: int = None # type: ignore [assignment]
+    _name_length: int
+    _name: str
+    _parent_type: int
+    _stat_group: int
+    _str: int
+    _intl: int
+    _wis: int
+    _agi: int
+    _con: int
+    _cha: int
+
+    def __init__(self, *, name: str, parent_type: int, stat_group: int, str: int, intl: int, wis: int, agi: int, con: int, cha: int):
+        """
+        Create a new instance of EcfRecord.
+
+        Args:
+            name (str): (Length must be 252 or less.)
+            parent_type (int): (Value range is 0-252.)
+            stat_group (int): (Value range is 0-252.)
+            str (int): (Value range is 0-64008.)
+            intl (int): (Value range is 0-64008.)
+            wis (int): (Value range is 0-64008.)
+            agi (int): (Value range is 0-64008.)
+            con (int): (Value range is 0-64008.)
+            cha (int): (Value range is 0-64008.)
+        """
+        self._name = name
+        self._name_length = len(self._name)
+        self._parent_type = parent_type
+        self._stat_group = stat_group
+        self._str = str
+        self._intl = intl
+        self._wis = wis
+        self._agi = agi
+        self._con = con
+        self._cha = cha
 
     @property
     def byte_size(self) -> int:
@@ -35,149 +61,40 @@ class EcfRecord:
 
     @property
     def name(self) -> str:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
         return self._name
 
-    @name.setter
-    def name(self, name: str) -> None:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
-        self._name = name
-        self._name_length = len(self._name)
-
     @property
     def parent_type(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._parent_type
 
-    @parent_type.setter
-    def parent_type(self, parent_type: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._parent_type = parent_type
-
     @property
     def stat_group(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._stat_group
 
-    @stat_group.setter
-    def stat_group(self, stat_group: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._stat_group = stat_group
-
     @property
     def str(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._str
 
-    @str.setter
-    def str(self, str: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._str = str
-
     @property
     def intl(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._intl
 
-    @intl.setter
-    def intl(self, intl: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._intl = intl
-
     @property
     def wis(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._wis
 
-    @wis.setter
-    def wis(self, wis: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._wis = wis
-
     @property
     def agi(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._agi
 
-    @agi.setter
-    def agi(self, agi: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._agi = agi
-
     @property
     def con(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._con
 
-    @con.setter
-    def con(self, con: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._con = con
-
     @property
     def cha(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._cha
 
-    @cha.setter
-    def cha(self, cha: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._cha = cha
-
     @staticmethod
     def serialize(writer: EoWriter, data: "EcfRecord") -> None:
         """
@@ -187,38 +104,42 @@ class EcfRecord:
             writer (EoWriter): The writer that the data will be serialized to.
             data (EcfRecord): The data to serialize.
         """
-        if data._name_length is None:
-            raise SerializationError("name_length must be provided.")
-        writer.add_char(data._name_length)
-        if data._name is None:
-            raise SerializationError("name must be provided.")
-        if len(data._name) > 252:
-            raise SerializationError(f"Expected length of name to be 252 or less, got {len(data._name)}.")
-        writer.add_fixed_string(data._name, data._name_length, False)
-        if data._parent_type is None:
-            raise SerializationError("parent_type must be provided.")
-        writer.add_char(data._parent_type)
-        if data._stat_group is None:
-            raise SerializationError("stat_group must be provided.")
-        writer.add_char(data._stat_group)
-        if data._str is None:
-            raise SerializationError("str must be provided.")
-        writer.add_short(data._str)
-        if data._intl is None:
-            raise SerializationError("intl must be provided.")
-        writer.add_short(data._intl)
-        if data._wis is None:
-            raise SerializationError("wis must be provided.")
-        writer.add_short(data._wis)
-        if data._agi is None:
-            raise SerializationError("agi must be provided.")
-        writer.add_short(data._agi)
-        if data._con is None:
-            raise SerializationError("con must be provided.")
-        writer.add_short(data._con)
-        if data._cha is None:
-            raise SerializationError("cha must be provided.")
-        writer.add_short(data._cha)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._name_length is None:
+                raise SerializationError("name_length must be provided.")
+            writer.add_char(data._name_length)
+            if data._name is None:
+                raise SerializationError("name must be provided.")
+            if len(data._name) > 252:
+                raise SerializationError(f"Expected length of name to be 252 or less, got {len(data._name)}.")
+            writer.add_fixed_string(data._name, data._name_length, False)
+            if data._parent_type is None:
+                raise SerializationError("parent_type must be provided.")
+            writer.add_char(data._parent_type)
+            if data._stat_group is None:
+                raise SerializationError("stat_group must be provided.")
+            writer.add_char(data._stat_group)
+            if data._str is None:
+                raise SerializationError("str must be provided.")
+            writer.add_short(data._str)
+            if data._intl is None:
+                raise SerializationError("intl must be provided.")
+            writer.add_short(data._intl)
+            if data._wis is None:
+                raise SerializationError("wis must be provided.")
+            writer.add_short(data._wis)
+            if data._agi is None:
+                raise SerializationError("agi must be provided.")
+            writer.add_short(data._agi)
+            if data._con is None:
+                raise SerializationError("con must be provided.")
+            writer.add_short(data._con)
+            if data._cha is None:
+                raise SerializationError("cha must be provided.")
+            writer.add_short(data._cha)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "EcfRecord":
@@ -231,22 +152,22 @@ class EcfRecord:
         Returns:
             EcfRecord: The data to serialize.
         """
-        data: EcfRecord = EcfRecord()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._name_length = reader.get_char()
-            data._name = reader.get_fixed_string(data._name_length, False)
-            data._parent_type = reader.get_char()
-            data._stat_group = reader.get_char()
-            data._str = reader.get_short()
-            data._intl = reader.get_short()
-            data._wis = reader.get_short()
-            data._agi = reader.get_short()
-            data._con = reader.get_short()
-            data._cha = reader.get_short()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            name_length = reader.get_char()
+            name = reader.get_fixed_string(name_length, False)
+            parent_type = reader.get_char()
+            stat_group = reader.get_char()
+            str = reader.get_short()
+            intl = reader.get_short()
+            wis = reader.get_short()
+            agi = reader.get_short()
+            con = reader.get_short()
+            cha = reader.get_short()
+            result = EcfRecord(name=name, parent_type=parent_type, stat_group=stat_group, str=str, intl=intl, wis=wis, agi=agi, con=con, cha=cha)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/pub/eif.py

@@ -4,6 +4,7 @@
 # Changes will be lost when code is regenerated.
 
 from __future__ import annotations
+from collections.abc import Iterable
 from .eif_record import EifRecord
 from ...serialization_error import SerializationError
 from ....data.eo_writer import EoWriter
@@ -14,10 +15,25 @@ class Eif:
     Endless Item File
     """
     _byte_size: int = 0
-    _rid: list[int] = None # type: ignore [assignment]
-    _total_items_count: int = None # type: ignore [assignment]
-    _version: int = None # type: ignore [assignment]
-    _items: list[EifRecord] = None # type: ignore [assignment]
+    _rid: tuple[int, ...]
+    _total_items_count: int
+    _version: int
+    _items: tuple[EifRecord, ...]
+
+    def __init__(self, *, rid: Iterable[int], total_items_count: int, version: int, items: Iterable[EifRecord]):
+        """
+        Create a new instance of Eif.
+
+        Args:
+            rid (Iterable[int]): (Length must be `2`.) (Element value range is 0-64008.)
+            total_items_count (int): (Value range is 0-64008.)
+            version (int): (Value range is 0-252.)
+            items (Iterable[EifRecord]): 
+        """
+        self._rid = tuple(rid)
+        self._total_items_count = total_items_count
+        self._version = version
+        self._items = tuple(items)
 
     @property
     def byte_size(self) -> int:
@@ -30,63 +46,21 @@ class Eif:
         return self._byte_size
 
     @property
-    def rid(self) -> list[int]:
-        """
-        Note:
-          - Length must be `2`.
-          - Element value range is 0-64008.
-        """
+    def rid(self) -> tuple[int, ...]:
         return self._rid
 
-    @rid.setter
-    def rid(self, rid: list[int]) -> None:
-        """
-        Note:
-          - Length must be `2`.
-          - Element value range is 0-64008.
-        """
-        self._rid = rid
-
     @property
     def total_items_count(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._total_items_count
 
-    @total_items_count.setter
-    def total_items_count(self, total_items_count: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._total_items_count = total_items_count
-
     @property
     def version(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._version
 
-    @version.setter
-    def version(self, version: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._version = version
-
     @property
-    def items(self) -> list[EifRecord]:
+    def items(self) -> tuple[EifRecord, ...]:
         return self._items
 
-    @items.setter
-    def items(self, items: list[EifRecord]) -> None:
-        self._items = items
-
     @staticmethod
     def serialize(writer: EoWriter, data: "Eif") -> None:
         """
@@ -96,23 +70,27 @@ class Eif:
             writer (EoWriter): The writer that the data will be serialized to.
             data (Eif): The data to serialize.
         """
-        writer.add_fixed_string("EIF", 3, False)
-        if data._rid is None:
-            raise SerializationError("rid must be provided.")
-        if len(data._rid) != 2:
-            raise SerializationError(f"Expected length of rid to be exactly 2, got {len(data._rid)}.")
-        for i in range(2):
-            writer.add_short(data._rid[i])
-        if data._total_items_count is None:
-            raise SerializationError("total_items_count must be provided.")
-        writer.add_short(data._total_items_count)
-        if data._version is None:
-            raise SerializationError("version must be provided.")
-        writer.add_char(data._version)
-        if data._items is None:
-            raise SerializationError("items must be provided.")
-        for i in range(len(data._items)):
-            EifRecord.serialize(writer, data._items[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.add_fixed_string("EIF", 3, False)
+            if data._rid is None:
+                raise SerializationError("rid must be provided.")
+            if len(data._rid) != 2:
+                raise SerializationError(f"Expected length of rid to be exactly 2, got {len(data._rid)}.")
+            for i in range(2):
+                writer.add_short(data._rid[i])
+            if data._total_items_count is None:
+                raise SerializationError("total_items_count must be provided.")
+            writer.add_short(data._total_items_count)
+            if data._version is None:
+                raise SerializationError("version must be provided.")
+            writer.add_char(data._version)
+            if data._items is None:
+                raise SerializationError("items must be provided.")
+            for i in range(len(data._items)):
+                EifRecord.serialize(writer, data._items[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "Eif":
@@ -125,21 +103,21 @@ class Eif:
         Returns:
             Eif: The data to serialize.
         """
-        data: Eif = Eif()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.get_fixed_string(3, False)
-            data._rid = []
+            rid = []
             for i in range(2):
-                data._rid.append(reader.get_short())
-            data._total_items_count = reader.get_short()
-            data._version = reader.get_char()
-            data._items = []
+                rid.append(reader.get_short())
+            total_items_count = reader.get_short()
+            version = reader.get_char()
+            items = []
             while reader.remaining > 0:
-                data._items.append(EifRecord.deserialize(reader))
-            data._byte_size = reader.position - reader_start_position
-            return data
+                items.append(EifRecord.deserialize(reader))
+            result = Eif(rid=rid, total_items_count=total_items_count, version=version, items=items)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode