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

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 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]
@@ -106,20 +109,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":

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

@@ -15,6 +15,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 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
@@ -95,16 +98,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":
@@ -136,10 +145,9 @@ 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:
         """
@@ -192,12 +200,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":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class WarpCreateServerPacket(Packet):
+    """
+    Equivalent to INIT_INIT with InitReply.MapMutation
+    """
     _byte_size: int = 0
     _map_file: MapFile = None # type: ignore [assignment]
 
@@ -71,9 +74,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":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class WarpPlayerServerPacket(Packet):
+    """
+    Equivalent to INIT_INIT with InitReply.WarpMap
+    """
     _byte_size: int = 0
     _map_file: MapFile = None # type: ignore [assignment]
 
@@ -71,9 +74,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":

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

@@ -14,6 +14,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 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]
@@ -119,19 +122,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":
@@ -162,10 +169,9 @@ 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:
         """
@@ -228,15 +234,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":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class WelcomeNet242ServerPacket(Packet):
+    """
+    Equivalent to INIT_INIT with InitReply.FileEnf
+    """
     _byte_size: int = 0
     _pub_file: PubFile = None # type: ignore [assignment]
 
@@ -71,9 +74,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":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class WelcomeNet243ServerPacket(Packet):
+    """
+    Equivalent to INIT_INIT with InitReply.FileEsf
+    """
     _byte_size: int = 0
     _pub_file: PubFile = None # type: ignore [assignment]
 
@@ -71,9 +74,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":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class WelcomeNet244ServerPacket(Packet):
+    """
+    Equivalent to INIT_INIT with InitReply.FileEcf
+    """
     _byte_size: int = 0
     _pub_file: PubFile = None # type: ignore [assignment]
 
@@ -71,9 +74,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":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class WelcomePingServerPacket(Packet):
+    """
+    Equivalent to INIT_INIT with InitReply.FileMap
+    """
     _byte_size: int = 0
     _map_file: MapFile = None # type: ignore [assignment]
 
@@ -71,9 +74,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":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class WelcomePongServerPacket(Packet):
+    """
+    Equivalent to INIT_INIT with InitReply.FileEif
+    """
     _byte_size: int = 0
     _pub_file: PubFile = None # type: ignore [assignment]
 
@@ -71,9 +74,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":