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

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

@@ -81,9 +81,13 @@ class TradeCloseServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TradeCloseServerPacket): The data to serialize.
         """
-        if data._partner_player_id is None:
-            raise SerializationError("partner_player_id must be provided.")
-        writer.add_short(data._partner_player_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._partner_player_id is None:
+                raise SerializationError("partner_player_id must be provided.")
+            writer.add_short(data._partner_player_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TradeCloseServerPacket":

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

@@ -86,22 +86,28 @@ class TradeItemData:
             writer (EoWriter): The writer that the data will be serialized to.
             data (TradeItemData): The data to serialize.
         """
-        if data._partner_player_id is None:
-            raise SerializationError("partner_player_id must be provided.")
-        writer.add_short(data._partner_player_id)
-        if data._partner_items is None:
-            raise SerializationError("partner_items must be provided.")
-        for i in range(len(data._partner_items)):
-            Item.serialize(writer, data._partner_items[i])
-        writer.add_byte(0xFF)
-        if data._your_player_id is None:
-            raise SerializationError("your_player_id must be provided.")
-        writer.add_short(data._your_player_id)
-        if data._your_items is None:
-            raise SerializationError("your_items must be provided.")
-        for i in range(len(data._your_items)):
-            Item.serialize(writer, data._your_items[i])
-        writer.add_byte(0xFF)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._partner_player_id is None:
+                raise SerializationError("partner_player_id must be provided.")
+            writer.add_short(data._partner_player_id)
+            if data._partner_items is None:
+                raise SerializationError("partner_items must be provided.")
+            for i in range(len(data._partner_items)):
+                Item.serialize(writer, data._partner_items[i])
+            writer.add_byte(0xFF)
+            if data._your_player_id is None:
+                raise SerializationError("your_player_id must be provided.")
+            writer.add_short(data._your_player_id)
+            if data._your_items is None:
+                raise SerializationError("your_items must be provided.")
+            for i in range(len(data._your_items)):
+                Item.serialize(writer, data._your_items[i])
+            writer.add_byte(0xFF)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TradeItemData":

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

@@ -116,20 +116,26 @@ class TradeOpenServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TradeOpenServerPacket): The data to serialize.
         """
-        if data._partner_player_id is None:
-            raise SerializationError("partner_player_id must be provided.")
-        writer.add_short(data._partner_player_id)
-        if data._partner_player_name is None:
-            raise SerializationError("partner_player_name must be provided.")
-        writer.add_string(data._partner_player_name)
-        writer.add_byte(0xFF)
-        if data._your_player_id is None:
-            raise SerializationError("your_player_id must be provided.")
-        writer.add_short(data._your_player_id)
-        if data._your_player_name is None:
-            raise SerializationError("your_player_name must be provided.")
-        writer.add_string(data._your_player_name)
-        writer.add_byte(0xFF)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._partner_player_id is None:
+                raise SerializationError("partner_player_id must be provided.")
+            writer.add_short(data._partner_player_id)
+            if data._partner_player_name is None:
+                raise SerializationError("partner_player_name must be provided.")
+            writer.add_string(data._partner_player_name)
+            writer.add_byte(0xFF)
+            if data._your_player_id is None:
+                raise SerializationError("your_player_id must be provided.")
+            writer.add_short(data._your_player_id)
+            if data._your_player_name is None:
+                raise SerializationError("your_player_name must be provided.")
+            writer.add_string(data._your_player_name)
+            writer.add_byte(0xFF)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TradeOpenServerPacket":

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

@@ -74,9 +74,13 @@ class TradeReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TradeReplyServerPacket): The data to serialize.
         """
-        if data._trade_data is None:
-            raise SerializationError("trade_data must be provided.")
-        TradeItemData.serialize(writer, data._trade_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._trade_data is None:
+                raise SerializationError("trade_data must be provided.")
+            TradeItemData.serialize(writer, data._trade_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TradeReplyServerPacket":

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

@@ -90,13 +90,17 @@ class TradeRequestServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TradeRequestServerPacket): The data to serialize.
         """
-        writer.add_char(138)
-        if data._partner_player_id is None:
-            raise SerializationError("partner_player_id must be provided.")
-        writer.add_short(data._partner_player_id)
-        if data._partner_player_name is None:
-            raise SerializationError("partner_player_name must be provided.")
-        writer.add_string(data._partner_player_name)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.add_char(138)
+            if data._partner_player_id is None:
+                raise SerializationError("partner_player_id must be provided.")
+            writer.add_short(data._partner_player_id)
+            if data._partner_player_name is None:
+                raise SerializationError("partner_player_name must be provided.")
+            writer.add_string(data._partner_player_name)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TradeRequestServerPacket":

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

@@ -73,9 +73,13 @@ class TradeSpecServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TradeSpecServerPacket): The data to serialize.
         """
-        if data._agree is None:
-            raise SerializationError("agree must be provided.")
-        writer.add_char(1 if data._agree else 0)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._agree is None:
+                raise SerializationError("agree must be provided.")
+            writer.add_char(1 if data._agree else 0)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TradeSpecServerPacket":

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

@@ -74,9 +74,13 @@ class TradeUseServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TradeUseServerPacket): The data to serialize.
         """
-        if data._trade_data is None:
-            raise SerializationError("trade_data must be provided.")
-        TradeItemData.serialize(writer, data._trade_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._trade_data is None:
+                raise SerializationError("trade_data must be provided.")
+            TradeItemData.serialize(writer, data._trade_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TradeUseServerPacket":

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

@@ -63,9 +63,11 @@ class WalkCloseServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (WalkCloseServerPacket): The data to serialize.
         """
-        old_writer_length: int = len(writer)
-        if len(writer) == old_writer_length:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
             writer.add_string("S")
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "WalkCloseServerPacket":
@@ -82,8 +84,7 @@ class WalkCloseServerPacket(Packet):
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            if reader.position == reader_start_position:
-                reader.get_string()
+            reader.get_string()
             data._byte_size = reader.position - reader_start_position
             return data
         finally:

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

@@ -63,9 +63,11 @@ class WalkOpenServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (WalkOpenServerPacket): The data to serialize.
         """
-        old_writer_length: int = len(writer)
-        if len(writer) == old_writer_length:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
             writer.add_string("S")
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "WalkOpenServerPacket":
@@ -82,8 +84,7 @@ class WalkOpenServerPacket(Packet):
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            if reader.position == reader_start_position:
-                reader.get_string()
+            reader.get_string()
             data._byte_size = reader.position - reader_start_position
             return data
         finally:

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

@@ -121,15 +121,19 @@ class WalkPlayerServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (WalkPlayerServerPacket): The data to serialize.
         """
-        if data._player_id is None:
-            raise SerializationError("player_id must be provided.")
-        writer.add_short(data._player_id)
-        if data._direction is None:
-            raise SerializationError("direction must be provided.")
-        writer.add_char(int(data._direction))
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._player_id is None:
+                raise SerializationError("player_id must be provided.")
+            writer.add_short(data._player_id)
+            if data._direction is None:
+                raise SerializationError("direction must be provided.")
+            writer.add_char(int(data._direction))
+            if data._coords is None:
+                raise SerializationError("coords must be provided.")
+            Coords.serialize(writer, data._coords)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "WalkPlayerServerPacket":

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

@@ -109,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

@@ -98,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":
@@ -139,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:
         """
@@ -195,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

@@ -74,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

@@ -74,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

@@ -122,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":
@@ -165,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:
         """
@@ -231,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

@@ -74,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

@@ -74,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

@@ -74,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

@@ -74,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

@@ -74,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":