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

eolib/protocol/_generated/pub/server/shop_record.py

@@ -4,6 +4,7 @@
 # Changes will be lost when code is regenerated.
 
 from __future__ import annotations
+from collections.abc import Iterable
 from .shop_trade_record import ShopTradeRecord
 from .shop_craft_record import ShopCraftRecord
 from ....serialization_error import SerializationError
@@ -15,16 +16,40 @@ class ShopRecord:
     Record of Shop data in an Endless Shop File
     """
     _byte_size: int = 0
-    _behavior_id: int = None # type: ignore [assignment]
-    _name_length: int = None # type: ignore [assignment]
-    _name: str = None # type: ignore [assignment]
-    _min_level: int = None # type: ignore [assignment]
-    _max_level: int = None # type: ignore [assignment]
-    _class_requirement: int = None # type: ignore [assignment]
-    _trades_count: int = None # type: ignore [assignment]
-    _crafts_count: int = None # type: ignore [assignment]
-    _trades: list[ShopTradeRecord] = None # type: ignore [assignment]
-    _crafts: list[ShopCraftRecord] = None # type: ignore [assignment]
+    _behavior_id: int
+    _name_length: int
+    _name: str
+    _min_level: int
+    _max_level: int
+    _class_requirement: int
+    _trades_count: int
+    _crafts_count: int
+    _trades: tuple[ShopTradeRecord, ...]
+    _crafts: tuple[ShopCraftRecord, ...]
+
+    def __init__(self, *, behavior_id: int, name: str, min_level: int, max_level: int, class_requirement: int, trades: Iterable[ShopTradeRecord], crafts: Iterable[ShopCraftRecord]):
+        """
+        Create a new instance of ShopRecord.
+
+        Args:
+            behavior_id (int): (Value range is 0-64008.)
+            name (str): (Length must be 252 or less.)
+            min_level (int): Minimum level required to use this shop (Value range is 0-252.)
+            max_level (int): Maximum level allowed to use this shop (Value range is 0-252.)
+            class_requirement (int): Class required to use this shop (Value range is 0-252.)
+            trades (Iterable[ShopTradeRecord]): (Length must be 64008 or less.)
+            crafts (Iterable[ShopCraftRecord]): (Length must be 252 or less.)
+        """
+        self._behavior_id = behavior_id
+        self._name = name
+        self._name_length = len(self._name)
+        self._min_level = min_level
+        self._max_level = max_level
+        self._class_requirement = class_requirement
+        self._trades = tuple(trades)
+        self._trades_count = len(self._trades)
+        self._crafts = tuple(crafts)
+        self._crafts_count = len(self._crafts)
 
     @property
     def byte_size(self) -> int:
@@ -38,131 +63,41 @@ class ShopRecord:
 
     @property
     def behavior_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._behavior_id
 
-    @behavior_id.setter
-    def behavior_id(self, behavior_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._behavior_id = behavior_id
-
     @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 min_level(self) -> int:
         """
         Minimum level required to use this shop
-
-        Note:
-          - Value range is 0-252.
         """
         return self._min_level
 
-    @min_level.setter
-    def min_level(self, min_level: int) -> None:
-        """
-        Minimum level required to use this shop
-
-        Note:
-          - Value range is 0-252.
-        """
-        self._min_level = min_level
-
     @property
     def max_level(self) -> int:
         """
         Maximum level allowed to use this shop
-
-        Note:
-          - Value range is 0-252.
         """
         return self._max_level
 
-    @max_level.setter
-    def max_level(self, max_level: int) -> None:
-        """
-        Maximum level allowed to use this shop
-
-        Note:
-          - Value range is 0-252.
-        """
-        self._max_level = max_level
-
     @property
     def class_requirement(self) -> int:
         """
         Class required to use this shop
-
-        Note:
-          - Value range is 0-252.
         """
         return self._class_requirement
 
-    @class_requirement.setter
-    def class_requirement(self, class_requirement: int) -> None:
-        """
-        Class required to use this shop
-
-        Note:
-          - Value range is 0-252.
-        """
-        self._class_requirement = class_requirement
-
     @property
-    def trades(self) -> list[ShopTradeRecord]:
-        """
-        Note:
-          - Length must be 64008 or less.
-        """
+    def trades(self) -> tuple[ShopTradeRecord, ...]:
         return self._trades
 
-    @trades.setter
-    def trades(self, trades: list[ShopTradeRecord]) -> None:
-        """
-        Note:
-          - Length must be 64008 or less.
-        """
-        self._trades = trades
-        self._trades_count = len(self._trades)
-
     @property
-    def crafts(self) -> list[ShopCraftRecord]:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
+    def crafts(self) -> tuple[ShopCraftRecord, ...]:
         return self._crafts
 
-    @crafts.setter
-    def crafts(self, crafts: list[ShopCraftRecord]) -> None:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
-        self._crafts = crafts
-        self._crafts_count = len(self._crafts)
-
     @staticmethod
     def serialize(writer: EoWriter, data: "ShopRecord") -> None:
         """
@@ -226,26 +161,26 @@ class ShopRecord:
         Returns:
             ShopRecord: The data to serialize.
         """
-        data: ShopRecord = ShopRecord()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._behavior_id = reader.get_short()
-            data._name_length = reader.get_char()
-            data._name = reader.get_fixed_string(data._name_length, False)
-            data._min_level = reader.get_char()
-            data._max_level = reader.get_char()
-            data._class_requirement = reader.get_char()
-            data._trades_count = reader.get_short()
-            data._crafts_count = reader.get_char()
-            data._trades = []
-            for i in range(data._trades_count):
-                data._trades.append(ShopTradeRecord.deserialize(reader))
-            data._crafts = []
-            for i in range(data._crafts_count):
-                data._crafts.append(ShopCraftRecord.deserialize(reader))
-            data._byte_size = reader.position - reader_start_position
-            return data
+            behavior_id = reader.get_short()
+            name_length = reader.get_char()
+            name = reader.get_fixed_string(name_length, False)
+            min_level = reader.get_char()
+            max_level = reader.get_char()
+            class_requirement = reader.get_char()
+            trades_count = reader.get_short()
+            crafts_count = reader.get_char()
+            trades = []
+            for i in range(trades_count):
+                trades.append(ShopTradeRecord.deserialize(reader))
+            crafts = []
+            for i in range(crafts_count):
+                crafts.append(ShopCraftRecord.deserialize(reader))
+            result = ShopRecord(behavior_id=behavior_id, name=name, min_level=min_level, max_level=max_level, class_requirement=class_requirement, trades=trades, crafts=crafts)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/pub/server/shop_trade_record.py

@@ -12,10 +12,25 @@ class ShopTradeRecord:
     Record of an item that can be bought or sold in a shop
     """
     _byte_size: int = 0
-    _item_id: int = None # type: ignore [assignment]
-    _buy_price: int = None # type: ignore [assignment]
-    _sell_price: int = None # type: ignore [assignment]
-    _max_amount: int = None # type: ignore [assignment]
+    _item_id: int
+    _buy_price: int
+    _sell_price: int
+    _max_amount: int
+
+    def __init__(self, *, item_id: int, buy_price: int, sell_price: int, max_amount: int):
+        """
+        Create a new instance of ShopTradeRecord.
+
+        Args:
+            item_id (int): (Value range is 0-64008.)
+            buy_price (int): How much it costs to buy the item from the shop (Value range is 0-16194276.)
+            sell_price (int): How much the shop will pay for the item (Value range is 0-16194276.)
+            max_amount (int): Max amount of the item that can be bought or sold at one time (Value range is 0-252.)
+        """
+        self._item_id = item_id
+        self._buy_price = buy_price
+        self._sell_price = sell_price
+        self._max_amount = max_amount
 
     @property
     def byte_size(self) -> int:
@@ -29,80 +44,29 @@ class ShopTradeRecord:
 
     @property
     def item_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._item_id
 
-    @item_id.setter
-    def item_id(self, item_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._item_id = item_id
-
     @property
     def buy_price(self) -> int:
         """
         How much it costs to buy the item from the shop
-
-        Note:
-          - Value range is 0-16194276.
         """
         return self._buy_price
 
-    @buy_price.setter
-    def buy_price(self, buy_price: int) -> None:
-        """
-        How much it costs to buy the item from the shop
-
-        Note:
-          - Value range is 0-16194276.
-        """
-        self._buy_price = buy_price
-
     @property
     def sell_price(self) -> int:
         """
         How much the shop will pay for the item
-
-        Note:
-          - Value range is 0-16194276.
         """
         return self._sell_price
 
-    @sell_price.setter
-    def sell_price(self, sell_price: int) -> None:
-        """
-        How much the shop will pay for the item
-
-        Note:
-          - Value range is 0-16194276.
-        """
-        self._sell_price = sell_price
-
     @property
     def max_amount(self) -> int:
         """
         Max amount of the item that can be bought or sold at one time
-
-        Note:
-          - Value range is 0-252.
         """
         return self._max_amount
 
-    @max_amount.setter
-    def max_amount(self, max_amount: int) -> None:
-        """
-        Max amount of the item that can be bought or sold at one time
-
-        Note:
-          - Value range is 0-252.
-        """
-        self._max_amount = max_amount
-
     @staticmethod
     def serialize(writer: EoWriter, data: "ShopTradeRecord") -> None:
         """
@@ -140,16 +104,16 @@ class ShopTradeRecord:
         Returns:
             ShopTradeRecord: The data to serialize.
         """
-        data: ShopTradeRecord = ShopTradeRecord()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._item_id = reader.get_short()
-            data._buy_price = reader.get_three()
-            data._sell_price = reader.get_three()
-            data._max_amount = reader.get_char()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            item_id = reader.get_short()
+            buy_price = reader.get_three()
+            sell_price = reader.get_three()
+            max_amount = reader.get_char()
+            result = ShopTradeRecord(item_id=item_id, buy_price=buy_price, sell_price=sell_price, max_amount=max_amount)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/pub/server/skill_master_file.py

@@ -4,6 +4,7 @@
 # Changes will be lost when code is regenerated.
 
 from __future__ import annotations
+from collections.abc import Iterable
 from .skill_master_record import SkillMasterRecord
 from ....serialization_error import SerializationError
 from .....data.eo_writer import EoWriter
@@ -14,7 +15,16 @@ class SkillMasterFile:
     Endless Skill Master File
     """
     _byte_size: int = 0
-    _skill_masters: list[SkillMasterRecord] = None # type: ignore [assignment]
+    _skill_masters: tuple[SkillMasterRecord, ...]
+
+    def __init__(self, *, skill_masters: Iterable[SkillMasterRecord]):
+        """
+        Create a new instance of SkillMasterFile.
+
+        Args:
+            skill_masters (Iterable[SkillMasterRecord]): 
+        """
+        self._skill_masters = tuple(skill_masters)
 
     @property
     def byte_size(self) -> int:
@@ -27,13 +37,9 @@ class SkillMasterFile:
         return self._byte_size
 
     @property
-    def skill_masters(self) -> list[SkillMasterRecord]:
+    def skill_masters(self) -> tuple[SkillMasterRecord, ...]:
         return self._skill_masters
 
-    @skill_masters.setter
-    def skill_masters(self, skill_masters: list[SkillMasterRecord]) -> None:
-        self._skill_masters = skill_masters
-
     @staticmethod
     def serialize(writer: EoWriter, data: "SkillMasterFile") -> None:
         """
@@ -64,16 +70,16 @@ class SkillMasterFile:
         Returns:
             SkillMasterFile: The data to serialize.
         """
-        data: SkillMasterFile = SkillMasterFile()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.get_fixed_string(3, False)
-            data._skill_masters = []
+            skill_masters = []
             while reader.remaining > 0:
-                data._skill_masters.append(SkillMasterRecord.deserialize(reader))
-            data._byte_size = reader.position - reader_start_position
-            return data
+                skill_masters.append(SkillMasterRecord.deserialize(reader))
+            result = SkillMasterFile(skill_masters=skill_masters)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/pub/server/skill_master_record.py

@@ -4,6 +4,7 @@
 # Changes will be lost when code is regenerated.
 
 from __future__ import annotations
+from collections.abc import Iterable
 from .skill_master_skill_record import SkillMasterSkillRecord
 from ....serialization_error import SerializationError
 from .....data.eo_writer import EoWriter
@@ -14,14 +15,35 @@ class SkillMasterRecord:
     Record of Skill Master data in an Endless Skill Master File
     """
     _byte_size: int = 0
-    _behavior_id: int = None # type: ignore [assignment]
-    _name_length: int = None # type: ignore [assignment]
-    _name: str = None # type: ignore [assignment]
-    _min_level: int = None # type: ignore [assignment]
-    _max_level: int = None # type: ignore [assignment]
-    _class_requirement: int = None # type: ignore [assignment]
-    _skills_count: int = None # type: ignore [assignment]
-    _skills: list[SkillMasterSkillRecord] = None # type: ignore [assignment]
+    _behavior_id: int
+    _name_length: int
+    _name: str
+    _min_level: int
+    _max_level: int
+    _class_requirement: int
+    _skills_count: int
+    _skills: tuple[SkillMasterSkillRecord, ...]
+
+    def __init__(self, *, behavior_id: int, name: str, min_level: int, max_level: int, class_requirement: int, skills: Iterable[SkillMasterSkillRecord]):
+        """
+        Create a new instance of SkillMasterRecord.
+
+        Args:
+            behavior_id (int): Behavior ID of the Skill Master NPC (Value range is 0-64008.)
+            name (str): (Length must be 252 or less.)
+            min_level (int): Minimum level required to use this Skill Master (Value range is 0-252.)
+            max_level (int): Maximum level allowed to use this Skill Master (Value range is 0-252.)
+            class_requirement (int): Class required to use this Skill Master (Value range is 0-252.)
+            skills (Iterable[SkillMasterSkillRecord]): (Length must be 64008 or less.)
+        """
+        self._behavior_id = behavior_id
+        self._name = name
+        self._name_length = len(self._name)
+        self._min_level = min_level
+        self._max_level = max_level
+        self._class_requirement = class_requirement
+        self._skills = tuple(skills)
+        self._skills_count = len(self._skills)
 
     @property
     def byte_size(self) -> int:
@@ -37,116 +59,38 @@ class SkillMasterRecord:
     def behavior_id(self) -> int:
         """
         Behavior ID of the Skill Master NPC
-
-        Note:
-          - Value range is 0-64008.
         """
         return self._behavior_id
 
-    @behavior_id.setter
-    def behavior_id(self, behavior_id: int) -> None:
-        """
-        Behavior ID of the Skill Master NPC
-
-        Note:
-          - Value range is 0-64008.
-        """
-        self._behavior_id = behavior_id
-
     @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 min_level(self) -> int:
         """
         Minimum level required to use this Skill Master
-
-        Note:
-          - Value range is 0-252.
         """
         return self._min_level
 
-    @min_level.setter
-    def min_level(self, min_level: int) -> None:
-        """
-        Minimum level required to use this Skill Master
-
-        Note:
-          - Value range is 0-252.
-        """
-        self._min_level = min_level
-
     @property
     def max_level(self) -> int:
         """
         Maximum level allowed to use this Skill Master
-
-        Note:
-          - Value range is 0-252.
         """
         return self._max_level
 
-    @max_level.setter
-    def max_level(self, max_level: int) -> None:
-        """
-        Maximum level allowed to use this Skill Master
-
-        Note:
-          - Value range is 0-252.
-        """
-        self._max_level = max_level
-
     @property
     def class_requirement(self) -> int:
         """
         Class required to use this Skill Master
-
-        Note:
-          - Value range is 0-252.
         """
         return self._class_requirement
 
-    @class_requirement.setter
-    def class_requirement(self, class_requirement: int) -> None:
-        """
-        Class required to use this Skill Master
-
-        Note:
-          - Value range is 0-252.
-        """
-        self._class_requirement = class_requirement
-
     @property
-    def skills(self) -> list[SkillMasterSkillRecord]:
-        """
-        Note:
-          - Length must be 64008 or less.
-        """
+    def skills(self) -> tuple[SkillMasterSkillRecord, ...]:
         return self._skills
 
-    @skills.setter
-    def skills(self, skills: list[SkillMasterSkillRecord]) -> None:
-        """
-        Note:
-          - Length must be 64008 or less.
-        """
-        self._skills = skills
-        self._skills_count = len(self._skills)
-
     @staticmethod
     def serialize(writer: EoWriter, data: "SkillMasterRecord") -> None:
         """
@@ -201,22 +145,22 @@ class SkillMasterRecord:
         Returns:
             SkillMasterRecord: The data to serialize.
         """
-        data: SkillMasterRecord = SkillMasterRecord()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._behavior_id = reader.get_short()
-            data._name_length = reader.get_char()
-            data._name = reader.get_fixed_string(data._name_length, False)
-            data._min_level = reader.get_char()
-            data._max_level = reader.get_char()
-            data._class_requirement = reader.get_char()
-            data._skills_count = reader.get_short()
-            data._skills = []
-            for i in range(data._skills_count):
-                data._skills.append(SkillMasterSkillRecord.deserialize(reader))
-            data._byte_size = reader.position - reader_start_position
-            return data
+            behavior_id = reader.get_short()
+            name_length = reader.get_char()
+            name = reader.get_fixed_string(name_length, False)
+            min_level = reader.get_char()
+            max_level = reader.get_char()
+            class_requirement = reader.get_char()
+            skills_count = reader.get_short()
+            skills = []
+            for i in range(skills_count):
+                skills.append(SkillMasterSkillRecord.deserialize(reader))
+            result = SkillMasterRecord(behavior_id=behavior_id, name=name, min_level=min_level, max_level=max_level, class_requirement=class_requirement, skills=skills)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode