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

eolib/protocol/_generated/net/server/walk_reply_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 .item_map_info import ItemMapInfo
 from ..packet_family import PacketFamily
 from ..packet_action import PacketAction
@@ -17,9 +18,22 @@ class WalkReplyServerPacket(Packet):
     Players, NPCs, and Items appearing in nearby view
     """
     _byte_size: int = 0
-    _player_ids: list[int] = None # type: ignore [assignment]
-    _npc_indexes: list[int] = None # type: ignore [assignment]
-    _items: list[ItemMapInfo] = None # type: ignore [assignment]
+    _player_ids: tuple[int, ...]
+    _npc_indexes: tuple[int, ...]
+    _items: tuple[ItemMapInfo, ...]
+
+    def __init__(self, *, player_ids: Iterable[int], npc_indexes: Iterable[int], items: Iterable[ItemMapInfo]):
+        """
+        Create a new instance of WalkReplyServerPacket.
+
+        Args:
+            player_ids (Iterable[int]): (Element value range is 0-64008.)
+            npc_indexes (Iterable[int]): (Element value range is 0-252.)
+            items (Iterable[ItemMapInfo]): 
+        """
+        self._player_ids = tuple(player_ids)
+        self._npc_indexes = tuple(npc_indexes)
+        self._items = tuple(items)
 
     @property
     def byte_size(self) -> int:
@@ -32,45 +46,17 @@ class WalkReplyServerPacket(Packet):
         return self._byte_size
 
     @property
-    def player_ids(self) -> list[int]:
-        """
-        Note:
-          - Element value range is 0-64008.
-        """
+    def player_ids(self) -> tuple[int, ...]:
         return self._player_ids
 
-    @player_ids.setter
-    def player_ids(self, player_ids: list[int]) -> None:
-        """
-        Note:
-          - Element value range is 0-64008.
-        """
-        self._player_ids = player_ids
-
     @property
-    def npc_indexes(self) -> list[int]:
-        """
-        Note:
-          - Element value range is 0-252.
-        """
+    def npc_indexes(self) -> tuple[int, ...]:
         return self._npc_indexes
 
-    @npc_indexes.setter
-    def npc_indexes(self, npc_indexes: list[int]) -> None:
-        """
-        Note:
-          - Element value range is 0-252.
-        """
-        self._npc_indexes = npc_indexes
-
     @property
-    def items(self) -> list[ItemMapInfo]:
+    def items(self) -> tuple[ItemMapInfo, ...]:
         return self._items
 
-    @items.setter
-    def items(self, items: list[ItemMapInfo]) -> None:
-        self._items = items
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -109,20 +95,26 @@ class WalkReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (WalkReplyServerPacket): The data to serialize.
         """
-        if data._player_ids is None:
-            raise SerializationError("player_ids must be provided.")
-        for i in range(len(data._player_ids)):
-            writer.add_short(data._player_ids[i])
-        writer.add_byte(0xFF)
-        if data._npc_indexes is None:
-            raise SerializationError("npc_indexes must be provided.")
-        for i in range(len(data._npc_indexes)):
-            writer.add_char(data._npc_indexes[i])
-        writer.add_byte(0xFF)
-        if data._items is None:
-            raise SerializationError("items must be provided.")
-        for i in range(len(data._items)):
-            ItemMapInfo.serialize(writer, data._items[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._player_ids is None:
+                raise SerializationError("player_ids must be provided.")
+            for i in range(len(data._player_ids)):
+                writer.add_short(data._player_ids[i])
+            writer.add_byte(0xFF)
+            if data._npc_indexes is None:
+                raise SerializationError("npc_indexes must be provided.")
+            for i in range(len(data._npc_indexes)):
+                writer.add_char(data._npc_indexes[i])
+            writer.add_byte(0xFF)
+            if data._items is None:
+                raise SerializationError("items must be provided.")
+            for i in range(len(data._items)):
+                ItemMapInfo.serialize(writer, data._items[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "WalkReplyServerPacket":
@@ -135,28 +127,28 @@ class WalkReplyServerPacket(Packet):
         Returns:
             WalkReplyServerPacket: The data to serialize.
         """
-        data: WalkReplyServerPacket = WalkReplyServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
             player_ids_length = int(reader.remaining / 2)
-            data._player_ids = []
+            player_ids = []
             for i in range(player_ids_length):
-                data._player_ids.append(reader.get_short())
+                player_ids.append(reader.get_short())
             reader.next_chunk()
             npc_indexes_length = int(reader.remaining / 1)
-            data._npc_indexes = []
+            npc_indexes = []
             for i in range(npc_indexes_length):
-                data._npc_indexes.append(reader.get_char())
+                npc_indexes.append(reader.get_char())
             reader.next_chunk()
             items_length = int(reader.remaining / 9)
-            data._items = []
+            items = []
             for i in range(items_length):
-                data._items.append(ItemMapInfo.deserialize(reader))
+                items.append(ItemMapInfo.deserialize(reader))
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = WalkReplyServerPacket(player_ids=player_ids, npc_indexes=npc_indexes, items=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/warp_agree_server_packet.py

@@ -19,9 +19,22 @@ class WarpAgreeServerPacket(Packet):
     Reply after accepting a warp
     """
     _byte_size: int = 0
-    _warp_type: WarpType = None # type: ignore [assignment]
-    _warp_type_data: 'WarpAgreeServerPacket.WarpTypeData' = None
-    _nearby: NearbyInfo = None # type: ignore [assignment]
+    _warp_type: WarpType
+    _warp_type_data: 'WarpAgreeServerPacket.WarpTypeData'
+    _nearby: NearbyInfo
+
+    def __init__(self, *, warp_type: WarpType, warp_type_data: 'WarpAgreeServerPacket.WarpTypeData' = None, nearby: NearbyInfo):
+        """
+        Create a new instance of WarpAgreeServerPacket.
+
+        Args:
+            warp_type (WarpType): 
+            warp_type_data (WarpAgreeServerPacket.WarpTypeData): Data associated with the `warp_type` field.
+            nearby (NearbyInfo): 
+        """
+        self._warp_type = warp_type
+        self._warp_type_data = warp_type_data
+        self._nearby = nearby
 
     @property
     def byte_size(self) -> int:
@@ -37,29 +50,17 @@ class WarpAgreeServerPacket(Packet):
     def warp_type(self) -> WarpType:
         return self._warp_type
 
-    @warp_type.setter
-    def warp_type(self, warp_type: WarpType) -> None:
-        self._warp_type = warp_type
-
     @property
     def warp_type_data(self) -> 'WarpAgreeServerPacket.WarpTypeData':
         """
-        WarpAgreeServerPacket.WarpTypeData: Gets or sets the data associated with the `warp_type` field.
+        WarpAgreeServerPacket.WarpTypeData: Data associated with the `warp_type` field.
         """
         return self._warp_type_data
 
-    @warp_type_data.setter
-    def warp_type_data(self, warp_type_data: 'WarpAgreeServerPacket.WarpTypeData') -> None:
-        self._warp_type_data = warp_type_data
-
     @property
     def nearby(self) -> NearbyInfo:
         return self._nearby
 
-    @nearby.setter
-    def nearby(self, nearby: NearbyInfo) -> None:
-        self._nearby = nearby
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -98,16 +99,22 @@ class WarpAgreeServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (WarpAgreeServerPacket): The data to serialize.
         """
-        if data._warp_type is None:
-            raise SerializationError("warp_type must be provided.")
-        writer.add_char(int(data._warp_type))
-        if data._warp_type == WarpType.MapSwitch:
-            if not isinstance(data._warp_type_data, WarpAgreeServerPacket.WarpTypeDataMapSwitch):
-                raise SerializationError("Expected warp_type_data to be type WarpAgreeServerPacket.WarpTypeDataMapSwitch for warp_type " + WarpType(data._warp_type).name + ".")
-            WarpAgreeServerPacket.WarpTypeDataMapSwitch.serialize(writer, data._warp_type_data)
-        if data._nearby is None:
-            raise SerializationError("nearby must be provided.")
-        NearbyInfo.serialize(writer, data._nearby)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._warp_type is None:
+                raise SerializationError("warp_type must be provided.")
+            writer.add_char(int(data._warp_type))
+            if data._warp_type == WarpType.MapSwitch:
+                if not isinstance(data._warp_type_data, WarpAgreeServerPacket.WarpTypeDataMapSwitch):
+                    raise SerializationError("Expected warp_type_data to be type WarpAgreeServerPacket.WarpTypeDataMapSwitch for warp_type " + WarpType(data._warp_type).name + ".")
+                WarpAgreeServerPacket.WarpTypeDataMapSwitch.serialize(writer, data._warp_type_data)
+            if data._nearby is None:
+                raise SerializationError("nearby must be provided.")
+            NearbyInfo.serialize(writer, data._nearby)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "WarpAgreeServerPacket":
@@ -120,18 +127,19 @@ class WarpAgreeServerPacket(Packet):
         Returns:
             WarpAgreeServerPacket: The data to serialize.
         """
-        data: WarpAgreeServerPacket = WarpAgreeServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
-            data._warp_type = WarpType(reader.get_char())
-            if data._warp_type == WarpType.MapSwitch:
-                data._warp_type_data = WarpAgreeServerPacket.WarpTypeDataMapSwitch.deserialize(reader)
-            data._nearby = NearbyInfo.deserialize(reader)
+            warp_type = WarpType(reader.get_char())
+            warp_type_data: WarpAgreeServerPacket.WarpTypeData = None
+            if warp_type == WarpType.MapSwitch:
+                warp_type_data = WarpAgreeServerPacket.WarpTypeDataMapSwitch.deserialize(reader)
+            nearby = NearbyInfo.deserialize(reader)
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = WarpAgreeServerPacket(warp_type=warp_type, warp_type_data=warp_type_data, nearby=nearby)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -139,18 +147,28 @@ class WarpAgreeServerPacket(Packet):
         return f"WarpAgreeServerPacket(byte_size={repr(self._byte_size)}, warp_type={repr(self._warp_type)}, warp_type_data={repr(self._warp_type_data)}, nearby={repr(self._nearby)})"
 
     WarpTypeData = Union['WarpAgreeServerPacket.WarpTypeDataMapSwitch', None]
-    WarpTypeData.__doc__ = \
-        """
-        Data associated with different values of the `warp_type` field.
-        """
+    """
+    Data associated with different values of the `warp_type` field.
+    """
 
     class WarpTypeDataMapSwitch:
         """
         Data associated with warp_type value WarpType.MapSwitch
         """
         _byte_size: int = 0
-        _map_id: int = None # type: ignore [assignment]
-        _warp_effect: WarpEffect = None # type: ignore [assignment]
+        _map_id: int
+        _warp_effect: WarpEffect
+
+        def __init__(self, *, map_id: int, warp_effect: WarpEffect):
+            """
+            Create a new instance of WarpAgreeServerPacket.WarpTypeDataMapSwitch.
+
+            Args:
+                map_id (int): (Value range is 0-64008.)
+                warp_effect (WarpEffect): 
+            """
+            self._map_id = map_id
+            self._warp_effect = warp_effect
 
         @property
         def byte_size(self) -> int:
@@ -164,28 +182,12 @@ class WarpAgreeServerPacket(Packet):
 
         @property
         def map_id(self) -> int:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
             return self._map_id
 
-        @map_id.setter
-        def map_id(self, map_id: int) -> None:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
-            self._map_id = map_id
-
         @property
         def warp_effect(self) -> WarpEffect:
             return self._warp_effect
 
-        @warp_effect.setter
-        def warp_effect(self, warp_effect: WarpEffect) -> None:
-            self._warp_effect = warp_effect
-
         @staticmethod
         def serialize(writer: EoWriter, data: "WarpAgreeServerPacket.WarpTypeDataMapSwitch") -> None:
             """
@@ -195,12 +197,16 @@ class WarpAgreeServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (WarpAgreeServerPacket.WarpTypeDataMapSwitch): The data to serialize.
             """
-            if data._map_id is None:
-                raise SerializationError("map_id must be provided.")
-            writer.add_short(data._map_id)
-            if data._warp_effect is None:
-                raise SerializationError("warp_effect must be provided.")
-            writer.add_char(int(data._warp_effect))
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._map_id is None:
+                    raise SerializationError("map_id must be provided.")
+                writer.add_short(data._map_id)
+                if data._warp_effect is None:
+                    raise SerializationError("warp_effect must be provided.")
+                writer.add_char(int(data._warp_effect))
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "WarpAgreeServerPacket.WarpTypeDataMapSwitch":
@@ -213,14 +219,14 @@ class WarpAgreeServerPacket(Packet):
             Returns:
                 WarpAgreeServerPacket.WarpTypeDataMapSwitch: The data to serialize.
             """
-            data: WarpAgreeServerPacket.WarpTypeDataMapSwitch = WarpAgreeServerPacket.WarpTypeDataMapSwitch()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._map_id = reader.get_short()
-                data._warp_effect = WarpEffect(reader.get_char())
-                data._byte_size = reader.position - reader_start_position
-                return data
+                map_id = reader.get_short()
+                warp_effect = WarpEffect(reader.get_char())
+                result = WarpAgreeServerPacket.WarpTypeDataMapSwitch(map_id=map_id, warp_effect=warp_effect)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -16,7 +16,16 @@ class WarpCreateServerPacket(Packet):
     Equivalent to INIT_INIT with InitReply.MapMutation
     """
     _byte_size: int = 0
-    _map_file: MapFile = None # type: ignore [assignment]
+    _map_file: MapFile
+
+    def __init__(self, *, map_file: MapFile):
+        """
+        Create a new instance of WarpCreateServerPacket.
+
+        Args:
+            map_file (MapFile): 
+        """
+        self._map_file = map_file
 
     @property
     def byte_size(self) -> int:
@@ -32,10 +41,6 @@ class WarpCreateServerPacket(Packet):
     def map_file(self) -> MapFile:
         return self._map_file
 
-    @map_file.setter
-    def map_file(self, map_file: MapFile) -> None:
-        self._map_file = map_file
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -74,9 +79,13 @@ class WarpCreateServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (WarpCreateServerPacket): The data to serialize.
         """
-        if data._map_file is None:
-            raise SerializationError("map_file must be provided.")
-        MapFile.serialize(writer, data._map_file)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._map_file is None:
+                raise SerializationError("map_file must be provided.")
+            MapFile.serialize(writer, data._map_file)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "WarpCreateServerPacket":
@@ -89,13 +98,13 @@ class WarpCreateServerPacket(Packet):
         Returns:
             WarpCreateServerPacket: The data to serialize.
         """
-        data: WarpCreateServerPacket = WarpCreateServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._map_file = MapFile.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            map_file = MapFile.deserialize(reader)
+            result = WarpCreateServerPacket(map_file=map_file)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -16,7 +16,16 @@ class WarpPlayerServerPacket(Packet):
     Equivalent to INIT_INIT with InitReply.WarpMap
     """
     _byte_size: int = 0
-    _map_file: MapFile = None # type: ignore [assignment]
+    _map_file: MapFile
+
+    def __init__(self, *, map_file: MapFile):
+        """
+        Create a new instance of WarpPlayerServerPacket.
+
+        Args:
+            map_file (MapFile): 
+        """
+        self._map_file = map_file
 
     @property
     def byte_size(self) -> int:
@@ -32,10 +41,6 @@ class WarpPlayerServerPacket(Packet):
     def map_file(self) -> MapFile:
         return self._map_file
 
-    @map_file.setter
-    def map_file(self, map_file: MapFile) -> None:
-        self._map_file = map_file
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -74,9 +79,13 @@ class WarpPlayerServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (WarpPlayerServerPacket): The data to serialize.
         """
-        if data._map_file is None:
-            raise SerializationError("map_file must be provided.")
-        MapFile.serialize(writer, data._map_file)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._map_file is None:
+                raise SerializationError("map_file must be provided.")
+            MapFile.serialize(writer, data._map_file)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "WarpPlayerServerPacket":
@@ -89,13 +98,13 @@ class WarpPlayerServerPacket(Packet):
         Returns:
             WarpPlayerServerPacket: The data to serialize.
         """
-        data: WarpPlayerServerPacket = WarpPlayerServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._map_file = MapFile.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            map_file = MapFile.deserialize(reader)
+            result = WarpPlayerServerPacket(map_file=map_file)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode