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

eolib/protocol/_generated/net/server/shop_craft_item.py

@@ -4,6 +4,7 @@
 # Changes will be lost when code is regenerated.
 
 from __future__ import annotations
+from collections.abc import Iterable
 from ..char_item import CharItem
 from ....serialization_error import SerializationError
 from .....data.eo_writer import EoWriter
@@ -14,8 +15,19 @@ class ShopCraftItem:
     An item that a shop can craft
     """
     _byte_size: int = 0
-    _item_id: int = None # type: ignore [assignment]
-    _ingredients: list[CharItem] = None # type: ignore [assignment]
+    _item_id: int
+    _ingredients: tuple[CharItem, ...]
+
+    def __init__(self, *, item_id: int, ingredients: Iterable[CharItem]):
+        """
+        Create a new instance of ShopCraftItem.
+
+        Args:
+            item_id (int): (Value range is 0-64008.)
+            ingredients (Iterable[CharItem]): (Length must be `4`.)
+        """
+        self._item_id = item_id
+        self._ingredients = tuple(ingredients)
 
     @property
     def byte_size(self) -> int:
@@ -29,36 +41,12 @@ class ShopCraftItem:
 
     @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[CharItem]:
-        """
-        Note:
-          - Length must be `4`.
-        """
+    def ingredients(self) -> tuple[CharItem, ...]:
         return self._ingredients
 
-    @ingredients.setter
-    def ingredients(self, ingredients: list[CharItem]) -> None:
-        """
-        Note:
-          - Length must be `4`.
-        """
-        self._ingredients = ingredients
-
     @staticmethod
     def serialize(writer: EoWriter, data: "ShopCraftItem") -> None:
         """
@@ -68,15 +56,19 @@ class ShopCraftItem:
             writer (EoWriter): The writer that the data will be serialized to.
             data (ShopCraftItem): The data to serialize.
         """
-        if data._item_id is None:
-            raise SerializationError("item_id must be provided.")
-        writer.add_short(data._item_id)
-        if data._ingredients is None:
-            raise SerializationError("ingredients must be provided.")
-        if len(data._ingredients) != 4:
-            raise SerializationError(f"Expected length of ingredients to be exactly 4, got {len(data._ingredients)}.")
-        for i in range(4):
-            CharItem.serialize(writer, data._ingredients[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._item_id is None:
+                raise SerializationError("item_id must be provided.")
+            writer.add_short(data._item_id)
+            if data._ingredients is None:
+                raise SerializationError("ingredients must be provided.")
+            if len(data._ingredients) != 4:
+                raise SerializationError(f"Expected length of ingredients to be exactly 4, got {len(data._ingredients)}.")
+            for i in range(4):
+                CharItem.serialize(writer, data._ingredients[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ShopCraftItem":
@@ -89,16 +81,16 @@ class ShopCraftItem:
         Returns:
             ShopCraftItem: The data to serialize.
         """
-        data: ShopCraftItem = ShopCraftItem()
         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(CharItem.deserialize(reader))
-            data._byte_size = reader.position - reader_start_position
-            return data
+                ingredients.append(CharItem.deserialize(reader))
+            result = ShopCraftItem(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/net/server/shop_create_server_packet.py

@@ -4,6 +4,7 @@
 # Changes will be lost when code is regenerated.
 
 from __future__ import annotations
+from collections.abc import Iterable
 from ..weight import Weight
 from ..packet_family import PacketFamily
 from ..packet_action import PacketAction
@@ -18,9 +19,22 @@ class ShopCreateServerPacket(Packet):
     Response to crafting an item from a shop
     """
     _byte_size: int = 0
-    _craft_item_id: int = None # type: ignore [assignment]
-    _weight: Weight = None # type: ignore [assignment]
-    _ingredients: list[Item] = None # type: ignore [assignment]
+    _craft_item_id: int
+    _weight: Weight
+    _ingredients: tuple[Item, ...]
+
+    def __init__(self, *, craft_item_id: int, weight: Weight, ingredients: Iterable[Item]):
+        """
+        Create a new instance of ShopCreateServerPacket.
+
+        Args:
+            craft_item_id (int): (Value range is 0-64008.)
+            weight (Weight): 
+            ingredients (Iterable[Item]): (Length must be `4`.)
+        """
+        self._craft_item_id = craft_item_id
+        self._weight = weight
+        self._ingredients = tuple(ingredients)
 
     @property
     def byte_size(self) -> int:
@@ -34,44 +48,16 @@ class ShopCreateServerPacket(Packet):
 
     @property
     def craft_item_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._craft_item_id
 
-    @craft_item_id.setter
-    def craft_item_id(self, craft_item_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._craft_item_id = craft_item_id
-
     @property
     def weight(self) -> Weight:
         return self._weight
 
-    @weight.setter
-    def weight(self, weight: Weight) -> None:
-        self._weight = weight
-
     @property
-    def ingredients(self) -> list[Item]:
-        """
-        Note:
-          - Length must be `4`.
-        """
+    def ingredients(self) -> tuple[Item, ...]:
         return self._ingredients
 
-    @ingredients.setter
-    def ingredients(self, ingredients: list[Item]) -> None:
-        """
-        Note:
-          - Length must be `4`.
-        """
-        self._ingredients = ingredients
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -110,18 +96,22 @@ class ShopCreateServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ShopCreateServerPacket): The data to serialize.
         """
-        if data._craft_item_id is None:
-            raise SerializationError("craft_item_id must be provided.")
-        writer.add_short(data._craft_item_id)
-        if data._weight is None:
-            raise SerializationError("weight must be provided.")
-        Weight.serialize(writer, data._weight)
-        if data._ingredients is None:
-            raise SerializationError("ingredients must be provided.")
-        if len(data._ingredients) != 4:
-            raise SerializationError(f"Expected length of ingredients to be exactly 4, got {len(data._ingredients)}.")
-        for i in range(4):
-            Item.serialize(writer, data._ingredients[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._craft_item_id is None:
+                raise SerializationError("craft_item_id must be provided.")
+            writer.add_short(data._craft_item_id)
+            if data._weight is None:
+                raise SerializationError("weight must be provided.")
+            Weight.serialize(writer, data._weight)
+            if data._ingredients is None:
+                raise SerializationError("ingredients must be provided.")
+            if len(data._ingredients) != 4:
+                raise SerializationError(f"Expected length of ingredients to be exactly 4, got {len(data._ingredients)}.")
+            for i in range(4):
+                Item.serialize(writer, data._ingredients[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ShopCreateServerPacket":
@@ -134,17 +124,17 @@ class ShopCreateServerPacket(Packet):
         Returns:
             ShopCreateServerPacket: The data to serialize.
         """
-        data: ShopCreateServerPacket = ShopCreateServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._craft_item_id = reader.get_short()
-            data._weight = Weight.deserialize(reader)
-            data._ingredients = []
+            craft_item_id = reader.get_short()
+            weight = Weight.deserialize(reader)
+            ingredients = []
             for i in range(4):
-                data._ingredients.append(Item.deserialize(reader))
-            data._byte_size = reader.position - reader_start_position
-            return data
+                ingredients.append(Item.deserialize(reader))
+            result = ShopCreateServerPacket(craft_item_id=craft_item_id, weight=weight, ingredients=ingredients)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/net/server/shop_open_server_packet.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_item import ShopTradeItem
 from .shop_craft_item import ShopCraftItem
 from ..packet_family import PacketFamily
@@ -18,10 +19,25 @@ class ShopOpenServerPacket(Packet):
     Response from talking to a shop NPC
     """
     _byte_size: int = 0
-    _session_id: int = None # type: ignore [assignment]
-    _shop_name: str = None # type: ignore [assignment]
-    _trade_items: list[ShopTradeItem] = None # type: ignore [assignment]
-    _craft_items: list[ShopCraftItem] = None # type: ignore [assignment]
+    _session_id: int
+    _shop_name: str
+    _trade_items: tuple[ShopTradeItem, ...]
+    _craft_items: tuple[ShopCraftItem, ...]
+
+    def __init__(self, *, session_id: int, shop_name: str, trade_items: Iterable[ShopTradeItem], craft_items: Iterable[ShopCraftItem]):
+        """
+        Create a new instance of ShopOpenServerPacket.
+
+        Args:
+            session_id (int): (Value range is 0-64008.)
+            shop_name (str): 
+            trade_items (Iterable[ShopTradeItem]): 
+            craft_items (Iterable[ShopCraftItem]): 
+        """
+        self._session_id = session_id
+        self._shop_name = shop_name
+        self._trade_items = tuple(trade_items)
+        self._craft_items = tuple(craft_items)
 
     @property
     def byte_size(self) -> int:
@@ -35,44 +51,20 @@ class ShopOpenServerPacket(Packet):
 
     @property
     def session_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._session_id
 
-    @session_id.setter
-    def session_id(self, session_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._session_id = session_id
-
     @property
     def shop_name(self) -> str:
         return self._shop_name
 
-    @shop_name.setter
-    def shop_name(self, shop_name: str) -> None:
-        self._shop_name = shop_name
-
     @property
-    def trade_items(self) -> list[ShopTradeItem]:
+    def trade_items(self) -> tuple[ShopTradeItem, ...]:
         return self._trade_items
 
-    @trade_items.setter
-    def trade_items(self, trade_items: list[ShopTradeItem]) -> None:
-        self._trade_items = trade_items
-
     @property
-    def craft_items(self) -> list[ShopCraftItem]:
+    def craft_items(self) -> tuple[ShopCraftItem, ...]:
         return self._craft_items
 
-    @craft_items.setter
-    def craft_items(self, craft_items: list[ShopCraftItem]) -> None:
-        self._craft_items = craft_items
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -111,23 +103,28 @@ class ShopOpenServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ShopOpenServerPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_short(data._session_id)
-        if data._shop_name is None:
-            raise SerializationError("shop_name must be provided.")
-        writer.add_string(data._shop_name)
-        writer.add_byte(0xFF)
-        if data._trade_items is None:
-            raise SerializationError("trade_items must be provided.")
-        for i in range(len(data._trade_items)):
-            ShopTradeItem.serialize(writer, data._trade_items[i])
-        writer.add_byte(0xFF)
-        if data._craft_items is None:
-            raise SerializationError("craft_items must be provided.")
-        for i in range(len(data._craft_items)):
-            ShopCraftItem.serialize(writer, data._craft_items[i])
-        writer.add_byte(0xFF)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_short(data._session_id)
+            if data._shop_name is None:
+                raise SerializationError("shop_name must be provided.")
+            writer.add_string(data._shop_name)
+            writer.add_byte(0xFF)
+            if data._trade_items is None:
+                raise SerializationError("trade_items must be provided.")
+            for i in range(len(data._trade_items)):
+                ShopTradeItem.serialize(writer, data._trade_items[i])
+            writer.add_byte(0xFF)
+            if data._craft_items is None:
+                raise SerializationError("craft_items must be provided.")
+            for i in range(len(data._craft_items)):
+                ShopCraftItem.serialize(writer, data._craft_items[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ShopOpenServerPacket":
@@ -140,27 +137,26 @@ class ShopOpenServerPacket(Packet):
         Returns:
             ShopOpenServerPacket: The data to serialize.
         """
-        data: ShopOpenServerPacket = ShopOpenServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
-            data._session_id = reader.get_short()
-            data._shop_name = reader.get_string()
+            session_id = reader.get_short()
+            shop_name = reader.get_string()
             reader.next_chunk()
             trade_items_length = int(reader.remaining / 9)
-            data._trade_items = []
+            trade_items = []
             for i in range(trade_items_length):
-                data._trade_items.append(ShopTradeItem.deserialize(reader))
+                trade_items.append(ShopTradeItem.deserialize(reader))
             reader.next_chunk()
             craft_items_length = int(reader.remaining / 14)
-            data._craft_items = []
+            craft_items = []
             for i in range(craft_items_length):
-                data._craft_items.append(ShopCraftItem.deserialize(reader))
-            reader.next_chunk()
+                craft_items.append(ShopCraftItem.deserialize(reader))
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = ShopOpenServerPacket(session_id=session_id, shop_name=shop_name, trade_items=trade_items, craft_items=craft_items)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/net/server/shop_sell_server_packet.py

@@ -17,9 +17,22 @@ class ShopSellServerPacket(Packet):
     Response to selling an item to a shop
     """
     _byte_size: int = 0
-    _sold_item: ShopSoldItem = None # type: ignore [assignment]
-    _gold_amount: int = None # type: ignore [assignment]
-    _weight: Weight = None # type: ignore [assignment]
+    _sold_item: ShopSoldItem
+    _gold_amount: int
+    _weight: Weight
+
+    def __init__(self, *, sold_item: ShopSoldItem, gold_amount: int, weight: Weight):
+        """
+        Create a new instance of ShopSellServerPacket.
+
+        Args:
+            sold_item (ShopSoldItem): 
+            gold_amount (int): (Value range is 0-4097152080.)
+            weight (Weight): 
+        """
+        self._sold_item = sold_item
+        self._gold_amount = gold_amount
+        self._weight = weight
 
     @property
     def byte_size(self) -> int:
@@ -35,34 +48,14 @@ class ShopSellServerPacket(Packet):
     def sold_item(self) -> ShopSoldItem:
         return self._sold_item
 
-    @sold_item.setter
-    def sold_item(self, sold_item: ShopSoldItem) -> None:
-        self._sold_item = sold_item
-
     @property
     def gold_amount(self) -> int:
-        """
-        Note:
-          - Value range is 0-4097152080.
-        """
         return self._gold_amount
 
-    @gold_amount.setter
-    def gold_amount(self, gold_amount: int) -> None:
-        """
-        Note:
-          - Value range is 0-4097152080.
-        """
-        self._gold_amount = gold_amount
-
     @property
     def weight(self) -> Weight:
         return self._weight
 
-    @weight.setter
-    def weight(self, weight: Weight) -> None:
-        self._weight = weight
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -101,15 +94,19 @@ class ShopSellServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ShopSellServerPacket): The data to serialize.
         """
-        if data._sold_item is None:
-            raise SerializationError("sold_item must be provided.")
-        ShopSoldItem.serialize(writer, data._sold_item)
-        if data._gold_amount is None:
-            raise SerializationError("gold_amount must be provided.")
-        writer.add_int(data._gold_amount)
-        if data._weight is None:
-            raise SerializationError("weight must be provided.")
-        Weight.serialize(writer, data._weight)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._sold_item is None:
+                raise SerializationError("sold_item must be provided.")
+            ShopSoldItem.serialize(writer, data._sold_item)
+            if data._gold_amount is None:
+                raise SerializationError("gold_amount must be provided.")
+            writer.add_int(data._gold_amount)
+            if data._weight is None:
+                raise SerializationError("weight must be provided.")
+            Weight.serialize(writer, data._weight)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ShopSellServerPacket":
@@ -122,15 +119,15 @@ class ShopSellServerPacket(Packet):
         Returns:
             ShopSellServerPacket: The data to serialize.
         """
-        data: ShopSellServerPacket = ShopSellServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._sold_item = ShopSoldItem.deserialize(reader)
-            data._gold_amount = reader.get_int()
-            data._weight = Weight.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            sold_item = ShopSoldItem.deserialize(reader)
+            gold_amount = reader.get_int()
+            weight = Weight.deserialize(reader)
+            result = ShopSellServerPacket(sold_item=sold_item, gold_amount=gold_amount, weight=weight)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/net/server/shop_sold_item.py

@@ -12,8 +12,19 @@ class ShopSoldItem:
     A sold item when selling an item to a shop
     """
     _byte_size: int = 0
-    _amount: int = None # type: ignore [assignment]
-    _id: int = None # type: ignore [assignment]
+    _amount: int
+    _id: int
+
+    def __init__(self, *, amount: int, id: int):
+        """
+        Create a new instance of ShopSoldItem.
+
+        Args:
+            amount (int): (Value range is 0-4097152080.)
+            id (int): (Value range is 0-64008.)
+        """
+        self._amount = amount
+        self._id = id
 
     @property
     def byte_size(self) -> int:
@@ -27,36 +38,12 @@ class ShopSoldItem:
 
     @property
     def amount(self) -> int:
-        """
-        Note:
-          - Value range is 0-4097152080.
-        """
         return self._amount
 
-    @amount.setter
-    def amount(self, amount: int) -> None:
-        """
-        Note:
-          - Value range is 0-4097152080.
-        """
-        self._amount = amount
-
     @property
     def id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._id
 
-    @id.setter
-    def id(self, id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._id = id
-
     @staticmethod
     def serialize(writer: EoWriter, data: "ShopSoldItem") -> None:
         """
@@ -66,12 +53,16 @@ class ShopSoldItem:
             writer (EoWriter): The writer that the data will be serialized to.
             data (ShopSoldItem): The data to serialize.
         """
-        if data._amount is None:
-            raise SerializationError("amount must be provided.")
-        writer.add_int(data._amount)
-        if data._id is None:
-            raise SerializationError("id must be provided.")
-        writer.add_short(data._id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._amount is None:
+                raise SerializationError("amount must be provided.")
+            writer.add_int(data._amount)
+            if data._id is None:
+                raise SerializationError("id must be provided.")
+            writer.add_short(data._id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ShopSoldItem":
@@ -84,14 +75,14 @@ class ShopSoldItem:
         Returns:
             ShopSoldItem: The data to serialize.
         """
-        data: ShopSoldItem = ShopSoldItem()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._amount = reader.get_int()
-            data._id = reader.get_short()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            amount = reader.get_int()
+            id = reader.get_short()
+            result = ShopSoldItem(amount=amount, id=id)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode