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

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

@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 from typing import Union
+from collections.abc import Iterable
 from .warp_type import WarpType
 from ..packet_family import PacketFamily
 from ..packet_action import PacketAction
@@ -18,10 +19,25 @@ class WarpRequestServerPacket(Packet):
     Warp request from server
     """
     _byte_size: int = 0
-    _warp_type: WarpType = None # type: ignore [assignment]
-    _map_id: int = None # type: ignore [assignment]
-    _warp_type_data: 'WarpRequestServerPacket.WarpTypeData' = None
-    _session_id: int = None # type: ignore [assignment]
+    _warp_type: WarpType
+    _map_id: int
+    _warp_type_data: 'WarpRequestServerPacket.WarpTypeData'
+    _session_id: int
+
+    def __init__(self, *, warp_type: WarpType, map_id: int, warp_type_data: 'WarpRequestServerPacket.WarpTypeData' = None, session_id: int):
+        """
+        Create a new instance of WarpRequestServerPacket.
+
+        Args:
+            warp_type (WarpType): 
+            map_id (int): (Value range is 0-64008.)
+            warp_type_data (WarpRequestServerPacket.WarpTypeData): Data associated with the `warp_type` field.
+            session_id (int): (Value range is 0-64008.)
+        """
+        self._warp_type = warp_type
+        self._map_id = map_id
+        self._warp_type_data = warp_type_data
+        self._session_id = session_id
 
     @property
     def byte_size(self) -> int:
@@ -37,53 +53,21 @@ class WarpRequestServerPacket(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 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_type_data(self) -> 'WarpRequestServerPacket.WarpTypeData':
         """
-        WarpRequestServerPacket.WarpTypeData: Gets or sets the data associated with the `warp_type` field.
+        WarpRequestServerPacket.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: 'WarpRequestServerPacket.WarpTypeData') -> None:
-        self._warp_type_data = warp_type_data
-
     @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
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -122,19 +106,23 @@ class WarpRequestServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (WarpRequestServerPacket): 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._map_id is None:
-            raise SerializationError("map_id must be provided.")
-        writer.add_short(data._map_id)
-        if data._warp_type == WarpType.MapSwitch:
-            if not isinstance(data._warp_type_data, WarpRequestServerPacket.WarpTypeDataMapSwitch):
-                raise SerializationError("Expected warp_type_data to be type WarpRequestServerPacket.WarpTypeDataMapSwitch for warp_type " + WarpType(data._warp_type).name + ".")
-            WarpRequestServerPacket.WarpTypeDataMapSwitch.serialize(writer, data._warp_type_data)
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_short(data._session_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._warp_type is None:
+                raise SerializationError("warp_type must be provided.")
+            writer.add_char(int(data._warp_type))
+            if data._map_id is None:
+                raise SerializationError("map_id must be provided.")
+            writer.add_short(data._map_id)
+            if data._warp_type == WarpType.MapSwitch:
+                if not isinstance(data._warp_type_data, WarpRequestServerPacket.WarpTypeDataMapSwitch):
+                    raise SerializationError("Expected warp_type_data to be type WarpRequestServerPacket.WarpTypeDataMapSwitch for warp_type " + WarpType(data._warp_type).name + ".")
+                WarpRequestServerPacket.WarpTypeDataMapSwitch.serialize(writer, data._warp_type_data)
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_short(data._session_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "WarpRequestServerPacket":
@@ -147,17 +135,18 @@ class WarpRequestServerPacket(Packet):
         Returns:
             WarpRequestServerPacket: The data to serialize.
         """
-        data: WarpRequestServerPacket = WarpRequestServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._warp_type = WarpType(reader.get_char())
-            data._map_id = reader.get_short()
-            if data._warp_type == WarpType.MapSwitch:
-                data._warp_type_data = WarpRequestServerPacket.WarpTypeDataMapSwitch.deserialize(reader)
-            data._session_id = reader.get_short()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            warp_type = WarpType(reader.get_char())
+            map_id = reader.get_short()
+            warp_type_data: WarpRequestServerPacket.WarpTypeData = None
+            if warp_type == WarpType.MapSwitch:
+                warp_type_data = WarpRequestServerPacket.WarpTypeDataMapSwitch.deserialize(reader)
+            session_id = reader.get_short()
+            result = WarpRequestServerPacket(warp_type=warp_type, map_id=map_id, warp_type_data=warp_type_data, session_id=session_id)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -165,18 +154,28 @@ class WarpRequestServerPacket(Packet):
         return f"WarpRequestServerPacket(byte_size={repr(self._byte_size)}, warp_type={repr(self._warp_type)}, map_id={repr(self._map_id)}, warp_type_data={repr(self._warp_type_data)}, session_id={repr(self._session_id)})"
 
     WarpTypeData = Union['WarpRequestServerPacket.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_rid: list[int] = None # type: ignore [assignment]
-        _map_file_size: int = None # type: ignore [assignment]
+        _map_rid: tuple[int, ...]
+        _map_file_size: int
+
+        def __init__(self, *, map_rid: Iterable[int], map_file_size: int):
+            """
+            Create a new instance of WarpRequestServerPacket.WarpTypeDataMapSwitch.
+
+            Args:
+                map_rid (Iterable[int]): (Length must be `2`.) (Element value range is 0-64008.)
+                map_file_size (int): (Value range is 0-16194276.)
+            """
+            self._map_rid = tuple(map_rid)
+            self._map_file_size = map_file_size
 
         @property
         def byte_size(self) -> int:
@@ -189,39 +188,13 @@ class WarpRequestServerPacket(Packet):
             return self._byte_size
 
         @property
-        def map_rid(self) -> list[int]:
-            """
-            Note:
-              - Length must be `2`.
-              - Element value range is 0-64008.
-            """
+        def map_rid(self) -> tuple[int, ...]:
             return self._map_rid
 
-        @map_rid.setter
-        def map_rid(self, map_rid: list[int]) -> None:
-            """
-            Note:
-              - Length must be `2`.
-              - Element value range is 0-64008.
-            """
-            self._map_rid = map_rid
-
         @property
         def map_file_size(self) -> int:
-            """
-            Note:
-              - Value range is 0-16194276.
-            """
             return self._map_file_size
 
-        @map_file_size.setter
-        def map_file_size(self, map_file_size: int) -> None:
-            """
-            Note:
-              - Value range is 0-16194276.
-            """
-            self._map_file_size = map_file_size
-
         @staticmethod
         def serialize(writer: EoWriter, data: "WarpRequestServerPacket.WarpTypeDataMapSwitch") -> None:
             """
@@ -231,15 +204,19 @@ class WarpRequestServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (WarpRequestServerPacket.WarpTypeDataMapSwitch): The data to serialize.
             """
-            if data._map_rid is None:
-                raise SerializationError("map_rid must be provided.")
-            if len(data._map_rid) != 2:
-                raise SerializationError(f"Expected length of map_rid to be exactly 2, got {len(data._map_rid)}.")
-            for i in range(2):
-                writer.add_short(data._map_rid[i])
-            if data._map_file_size is None:
-                raise SerializationError("map_file_size must be provided.")
-            writer.add_three(data._map_file_size)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._map_rid is None:
+                    raise SerializationError("map_rid must be provided.")
+                if len(data._map_rid) != 2:
+                    raise SerializationError(f"Expected length of map_rid to be exactly 2, got {len(data._map_rid)}.")
+                for i in range(2):
+                    writer.add_short(data._map_rid[i])
+                if data._map_file_size is None:
+                    raise SerializationError("map_file_size must be provided.")
+                writer.add_three(data._map_file_size)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "WarpRequestServerPacket.WarpTypeDataMapSwitch":
@@ -252,16 +229,16 @@ class WarpRequestServerPacket(Packet):
             Returns:
                 WarpRequestServerPacket.WarpTypeDataMapSwitch: The data to serialize.
             """
-            data: WarpRequestServerPacket.WarpTypeDataMapSwitch = WarpRequestServerPacket.WarpTypeDataMapSwitch()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._map_rid = []
+                map_rid = []
                 for i in range(2):
-                    data._map_rid.append(reader.get_short())
-                data._map_file_size = reader.get_three()
-                data._byte_size = reader.position - reader_start_position
-                return data
+                    map_rid.append(reader.get_short())
+                map_file_size = reader.get_three()
+                result = WarpRequestServerPacket.WarpTypeDataMapSwitch(map_rid=map_rid, map_file_size=map_file_size)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 

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

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

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

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

@@ -16,7 +16,16 @@ class WelcomePingServerPacket(Packet):
     Equivalent to INIT_INIT with InitReply.FileMap
     """
     _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 WelcomePingServerPacket.
+
+        Args:
+            map_file (MapFile): 
+        """
+        self._map_file = map_file
 
     @property
     def byte_size(self) -> int:
@@ -32,10 +41,6 @@ class WelcomePingServerPacket(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 WelcomePingServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (WelcomePingServerPacket): 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) -> "WelcomePingServerPacket":
@@ -89,13 +98,13 @@ class WelcomePingServerPacket(Packet):
         Returns:
             WelcomePingServerPacket: The data to serialize.
         """
-        data: WelcomePingServerPacket = WelcomePingServerPacket()
         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 = WelcomePingServerPacket(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/welcome_pong_server_packet.py

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