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

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

@@ -4,6 +4,7 @@
 # Changes will be lost when code is regenerated.
 
 from __future__ import annotations
+from collections.abc import Iterable
 from .inn_question_record import InnQuestionRecord
 from ....serialization_error import SerializationError
 from .....data.eo_writer import EoWriter
@@ -14,20 +15,54 @@ class InnRecord:
     Record of Inn data in an Endless Inn 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]
-    _spawn_map: int = None # type: ignore [assignment]
-    _spawn_x: int = None # type: ignore [assignment]
-    _spawn_y: int = None # type: ignore [assignment]
-    _sleep_map: int = None # type: ignore [assignment]
-    _sleep_x: int = None # type: ignore [assignment]
-    _sleep_y: int = None # type: ignore [assignment]
-    _alternate_spawn_enabled: bool = None # type: ignore [assignment]
-    _alternate_spawn_map: int = None # type: ignore [assignment]
-    _alternate_spawn_x: int = None # type: ignore [assignment]
-    _alternate_spawn_y: int = None # type: ignore [assignment]
-    _questions: list[InnQuestionRecord] = None # type: ignore [assignment]
+    _behavior_id: int
+    _name_length: int
+    _name: str
+    _spawn_map: int
+    _spawn_x: int
+    _spawn_y: int
+    _sleep_map: int
+    _sleep_x: int
+    _sleep_y: int
+    _alternate_spawn_enabled: bool
+    _alternate_spawn_map: int
+    _alternate_spawn_x: int
+    _alternate_spawn_y: int
+    _questions: tuple[InnQuestionRecord, ...]
+
+    def __init__(self, *, behavior_id: int, name: str, spawn_map: int, spawn_x: int, spawn_y: int, sleep_map: int, sleep_x: int, sleep_y: int, alternate_spawn_enabled: bool, alternate_spawn_map: int, alternate_spawn_x: int, alternate_spawn_y: int, questions: Iterable[InnQuestionRecord]):
+        """
+        Create a new instance of InnRecord.
+
+        Args:
+            behavior_id (int): Behavior ID of the NPC that runs the inn. 0 for default inn (Value range is 0-64008.)
+            name (str): (Length must be 252 or less.)
+            spawn_map (int): ID of the map the player is sent to after respawning (Value range is 0-64008.)
+            spawn_x (int): X coordinate of the map the player is sent to after respawning (Value range is 0-252.)
+            spawn_y (int): Y coordinate of the map the player is sent to after respawning (Value range is 0-252.)
+            sleep_map (int): ID of the map the player is sent to after sleeping at the inn (Value range is 0-64008.)
+            sleep_x (int): X coordinate of the map the player is sent to after sleeping at the inn (Value range is 0-252.)
+            sleep_y (int): Y coordinate of the map the player is sent to after sleeping at the inn (Value range is 0-252.)
+            alternate_spawn_enabled (bool): Flag for an alternate spawn point. If true, the server will use this alternate spawn map, x, and, y based on some other condition.  In the official server, this is used to respawn new characters on the noob island until they reach a certain level.
+            alternate_spawn_map (int): (Value range is 0-64008.)
+            alternate_spawn_x (int): (Value range is 0-252.)
+            alternate_spawn_y (int): (Value range is 0-252.)
+            questions (Iterable[InnQuestionRecord]): (Length must be `3`.)
+        """
+        self._behavior_id = behavior_id
+        self._name = name
+        self._name_length = len(self._name)
+        self._spawn_map = spawn_map
+        self._spawn_x = spawn_x
+        self._spawn_y = spawn_y
+        self._sleep_map = sleep_map
+        self._sleep_x = sleep_x
+        self._sleep_y = sleep_y
+        self._alternate_spawn_enabled = alternate_spawn_enabled
+        self._alternate_spawn_map = alternate_spawn_map
+        self._alternate_spawn_x = alternate_spawn_x
+        self._alternate_spawn_y = alternate_spawn_y
+        self._questions = tuple(questions)
 
     @property
     def byte_size(self) -> int:
@@ -43,159 +78,55 @@ class InnRecord:
     def behavior_id(self) -> int:
         """
         Behavior ID of the NPC that runs the inn. 0 for default inn
-
-        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 NPC that runs the inn. 0 for default inn
-
-        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 spawn_map(self) -> int:
         """
         ID of the map the player is sent to after respawning
-
-        Note:
-          - Value range is 0-64008.
         """
         return self._spawn_map
 
-    @spawn_map.setter
-    def spawn_map(self, spawn_map: int) -> None:
-        """
-        ID of the map the player is sent to after respawning
-
-        Note:
-          - Value range is 0-64008.
-        """
-        self._spawn_map = spawn_map
-
     @property
     def spawn_x(self) -> int:
         """
         X coordinate of the map the player is sent to after respawning
-
-        Note:
-          - Value range is 0-252.
         """
         return self._spawn_x
 
-    @spawn_x.setter
-    def spawn_x(self, spawn_x: int) -> None:
-        """
-        X coordinate of the map the player is sent to after respawning
-
-        Note:
-          - Value range is 0-252.
-        """
-        self._spawn_x = spawn_x
-
     @property
     def spawn_y(self) -> int:
         """
         Y coordinate of the map the player is sent to after respawning
-
-        Note:
-          - Value range is 0-252.
         """
         return self._spawn_y
 
-    @spawn_y.setter
-    def spawn_y(self, spawn_y: int) -> None:
-        """
-        Y coordinate of the map the player is sent to after respawning
-
-        Note:
-          - Value range is 0-252.
-        """
-        self._spawn_y = spawn_y
-
     @property
     def sleep_map(self) -> int:
         """
         ID of the map the player is sent to after sleeping at the inn
-
-        Note:
-          - Value range is 0-64008.
         """
         return self._sleep_map
 
-    @sleep_map.setter
-    def sleep_map(self, sleep_map: int) -> None:
-        """
-        ID of the map the player is sent to after sleeping at the inn
-
-        Note:
-          - Value range is 0-64008.
-        """
-        self._sleep_map = sleep_map
-
     @property
     def sleep_x(self) -> int:
         """
         X coordinate of the map the player is sent to after sleeping at the inn
-
-        Note:
-          - Value range is 0-252.
         """
         return self._sleep_x
 
-    @sleep_x.setter
-    def sleep_x(self, sleep_x: int) -> None:
-        """
-        X coordinate of the map the player is sent to after sleeping at the inn
-
-        Note:
-          - Value range is 0-252.
-        """
-        self._sleep_x = sleep_x
-
     @property
     def sleep_y(self) -> int:
         """
         Y coordinate of the map the player is sent to after sleeping at the inn
-
-        Note:
-          - Value range is 0-252.
         """
         return self._sleep_y
 
-    @sleep_y.setter
-    def sleep_y(self, sleep_y: int) -> None:
-        """
-        Y coordinate of the map the player is sent to after sleeping at the inn
-
-        Note:
-          - Value range is 0-252.
-        """
-        self._sleep_y = sleep_y
-
     @property
     def alternate_spawn_enabled(self) -> bool:
         """
@@ -207,81 +138,22 @@ class InnRecord:
         """
         return self._alternate_spawn_enabled
 
-    @alternate_spawn_enabled.setter
-    def alternate_spawn_enabled(self, alternate_spawn_enabled: bool) -> None:
-        """
-        Flag for an alternate spawn point. If true, the server will use this alternate spawn
-        map, x, and, y based on some other condition.
-
-        In the official server, this is used to respawn new characters on the noob island
-        until they reach a certain level.
-        """
-        self._alternate_spawn_enabled = alternate_spawn_enabled
-
     @property
     def alternate_spawn_map(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._alternate_spawn_map
 
-    @alternate_spawn_map.setter
-    def alternate_spawn_map(self, alternate_spawn_map: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._alternate_spawn_map = alternate_spawn_map
-
     @property
     def alternate_spawn_x(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._alternate_spawn_x
 
-    @alternate_spawn_x.setter
-    def alternate_spawn_x(self, alternate_spawn_x: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._alternate_spawn_x = alternate_spawn_x
-
     @property
     def alternate_spawn_y(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._alternate_spawn_y
 
-    @alternate_spawn_y.setter
-    def alternate_spawn_y(self, alternate_spawn_y: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._alternate_spawn_y = alternate_spawn_y
-
     @property
-    def questions(self) -> list[InnQuestionRecord]:
-        """
-        Note:
-          - Length must be `3`.
-        """
+    def questions(self) -> tuple[InnQuestionRecord, ...]:
         return self._questions
 
-    @questions.setter
-    def questions(self, questions: list[InnQuestionRecord]) -> None:
-        """
-        Note:
-          - Length must be `3`.
-        """
-        self._questions = questions
-
     @staticmethod
     def serialize(writer: EoWriter, data: "InnRecord") -> None:
         """
@@ -354,28 +226,28 @@ class InnRecord:
         Returns:
             InnRecord: The data to serialize.
         """
-        data: InnRecord = InnRecord()
         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._spawn_map = reader.get_short()
-            data._spawn_x = reader.get_char()
-            data._spawn_y = reader.get_char()
-            data._sleep_map = reader.get_short()
-            data._sleep_x = reader.get_char()
-            data._sleep_y = reader.get_char()
-            data._alternate_spawn_enabled = reader.get_char() != 0
-            data._alternate_spawn_map = reader.get_short()
-            data._alternate_spawn_x = reader.get_char()
-            data._alternate_spawn_y = reader.get_char()
-            data._questions = []
+            behavior_id = reader.get_short()
+            name_length = reader.get_char()
+            name = reader.get_fixed_string(name_length, False)
+            spawn_map = reader.get_short()
+            spawn_x = reader.get_char()
+            spawn_y = reader.get_char()
+            sleep_map = reader.get_short()
+            sleep_x = reader.get_char()
+            sleep_y = reader.get_char()
+            alternate_spawn_enabled = reader.get_char() != 0
+            alternate_spawn_map = reader.get_short()
+            alternate_spawn_x = reader.get_char()
+            alternate_spawn_y = reader.get_char()
+            questions = []
             for i in range(3):
-                data._questions.append(InnQuestionRecord.deserialize(reader))
-            data._byte_size = reader.position - reader_start_position
-            return data
+                questions.append(InnQuestionRecord.deserialize(reader))
+            result = InnRecord(behavior_id=behavior_id, name=name, spawn_map=spawn_map, spawn_x=spawn_x, spawn_y=spawn_y, sleep_map=sleep_map, sleep_x=sleep_x, sleep_y=sleep_y, alternate_spawn_enabled=alternate_spawn_enabled, alternate_spawn_map=alternate_spawn_map, alternate_spawn_x=alternate_spawn_x, alternate_spawn_y=alternate_spawn_y, questions=questions)
+            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_craft_ingredient_record.py

@@ -12,8 +12,19 @@ class ShopCraftIngredientRecord:
     Record of an ingredient for crafting an item in a shop
     """
     _byte_size: int = 0
-    _item_id: int = None # type: ignore [assignment]
-    _amount: int = None # type: ignore [assignment]
+    _item_id: int
+    _amount: int
+
+    def __init__(self, *, item_id: int, amount: int):
+        """
+        Create a new instance of ShopCraftIngredientRecord.
+
+        Args:
+            item_id (int): Item ID of the craft ingredient, or 0 if the ingredient is not present (Value range is 0-64008.)
+            amount (int): (Value range is 0-252.)
+        """
+        self._item_id = item_id
+        self._amount = amount
 
     @property
     def byte_size(self) -> int:
@@ -29,38 +40,13 @@ class ShopCraftIngredientRecord:
     def item_id(self) -> int:
         """
         Item ID of the craft ingredient, or 0 if the ingredient is not present
-
-        Note:
-          - Value range is 0-64008.
         """
         return self._item_id
 
-    @item_id.setter
-    def item_id(self, item_id: int) -> None:
-        """
-        Item ID of the craft ingredient, or 0 if the ingredient is not present
-
-        Note:
-          - Value range is 0-64008.
-        """
-        self._item_id = item_id
-
     @property
     def amount(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._amount
 
-    @amount.setter
-    def amount(self, amount: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._amount = amount
-
     @staticmethod
     def serialize(writer: EoWriter, data: "ShopCraftIngredientRecord") -> None:
         """
@@ -92,14 +78,14 @@ class ShopCraftIngredientRecord:
         Returns:
             ShopCraftIngredientRecord: The data to serialize.
         """
-        data: ShopCraftIngredientRecord = ShopCraftIngredientRecord()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._item_id = reader.get_short()
-            data._amount = reader.get_char()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            item_id = reader.get_short()
+            amount = reader.get_char()
+            result = ShopCraftIngredientRecord(item_id=item_id, amount=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/shop_craft_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_craft_ingredient_record import ShopCraftIngredientRecord
 from ....serialization_error import SerializationError
 from .....data.eo_writer import EoWriter
@@ -14,8 +15,19 @@ class ShopCraftRecord:
     Record of an item that can be crafted in a shop
     """
     _byte_size: int = 0
-    _item_id: int = None # type: ignore [assignment]
-    _ingredients: list[ShopCraftIngredientRecord] = None # type: ignore [assignment]
+    _item_id: int
+    _ingredients: tuple[ShopCraftIngredientRecord, ...]
+
+    def __init__(self, *, item_id: int, ingredients: Iterable[ShopCraftIngredientRecord]):
+        """
+        Create a new instance of ShopCraftRecord.
+
+        Args:
+            item_id (int): (Value range is 0-64008.)
+            ingredients (Iterable[ShopCraftIngredientRecord]): (Length must be `4`.)
+        """
+        self._item_id = item_id
+        self._ingredients = tuple(ingredients)
 
     @property
     def byte_size(self) -> int:
@@ -29,36 +41,12 @@ class ShopCraftRecord:
 
     @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 ingredients(self) -> list[ShopCraftIngredientRecord]:
-        """
-        Note:
-          - Length must be `4`.
-        """
+    def ingredients(self) -> tuple[ShopCraftIngredientRecord, ...]:
         return self._ingredients
 
-    @ingredients.setter
-    def ingredients(self, ingredients: list[ShopCraftIngredientRecord]) -> None:
-        """
-        Note:
-          - Length must be `4`.
-        """
-        self._ingredients = ingredients
-
     @staticmethod
     def serialize(writer: EoWriter, data: "ShopCraftRecord") -> None:
         """
@@ -93,16 +81,16 @@ class ShopCraftRecord:
         Returns:
             ShopCraftRecord: The data to serialize.
         """
-        data: ShopCraftRecord = ShopCraftRecord()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._item_id = reader.get_short()
-            data._ingredients = []
+            item_id = reader.get_short()
+            ingredients = []
             for i in range(4):
-                data._ingredients.append(ShopCraftIngredientRecord.deserialize(reader))
-            data._byte_size = reader.position - reader_start_position
-            return data
+                ingredients.append(ShopCraftIngredientRecord.deserialize(reader))
+            result = ShopCraftRecord(item_id=item_id, ingredients=ingredients)
+            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_file.py

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