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

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class PartyListServerPacket(Packet):
+    """
+    Party member list update
+    """
     _byte_size: int = 0
     _members: list[PartyMember] = None # type: ignore [assignment]
 
@@ -72,12 +75,17 @@ class PartyListServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PartyListServerPacket): The data to serialize.
         """
-        if data._members is None:
-            raise SerializationError("members must be provided.")
-        for i in range(len(data._members)):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._members is None:
+                raise SerializationError("members must be provided.")
+            for i in range(len(data._members)):
+                PartyMember.serialize(writer, data._members[i])
                 writer.add_byte(0xFF)
-            PartyMember.serialize(writer, data._members[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PartyListServerPacket":

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

@@ -9,7 +9,7 @@ from .....data.eo_reader import EoReader
 
 class PartyMember:
     """
-    A member of the player's party
+    A member of the player's party
     """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
@@ -101,21 +101,25 @@ class PartyMember:
             writer (EoWriter): The writer that the data will be serialized to.
             data (PartyMember): 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._leader is None:
-            raise SerializationError("leader must be provided.")
-        writer.add_char(1 if data._leader else 0)
-        if data._level is None:
-            raise SerializationError("level must be provided.")
-        writer.add_char(data._level)
-        if data._hp_percentage is None:
-            raise SerializationError("hp_percentage must be provided.")
-        writer.add_char(data._hp_percentage)
-        if data._name is None:
-            raise SerializationError("name must be provided.")
-        writer.add_string(data._name)
+        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._leader is None:
+                raise SerializationError("leader must be provided.")
+            writer.add_char(1 if data._leader else 0)
+            if data._level is None:
+                raise SerializationError("level must be provided.")
+            writer.add_char(data._level)
+            if data._hp_percentage is None:
+                raise SerializationError("hp_percentage must be provided.")
+            writer.add_char(data._hp_percentage)
+            if data._name is None:
+                raise SerializationError("name must be provided.")
+            writer.add_string(data._name)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PartyMember":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class PartyRemoveServerPacket(Packet):
+    """
+    Player left the party
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
 
@@ -78,9 +81,13 @@ class PartyRemoveServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PartyRemoveServerPacket): The data to serialize.
         """
-        if data._player_id is None:
-            raise SerializationError("player_id must be provided.")
-        writer.add_short(data._player_id)
+        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)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PartyRemoveServerPacket":

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class PartyReplyServerPacket(Packet):
+    """
+    Failed party invite / join request
+    """
     _byte_size: int = 0
     _reply_code: PartyReplyCode = None # type: ignore [assignment]
     _reply_code_data: 'PartyReplyServerPacket.ReplyCodeData' = None
@@ -84,17 +87,21 @@ class PartyReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PartyReplyServerPacket): The data to serialize.
         """
-        if data._reply_code is None:
-            raise SerializationError("reply_code must be provided.")
-        writer.add_char(int(data._reply_code))
-        if data._reply_code == PartyReplyCode.AlreadyInAnotherParty:
-            if not isinstance(data._reply_code_data, PartyReplyServerPacket.ReplyCodeDataAlreadyInAnotherParty):
-                raise SerializationError("Expected reply_code_data to be type PartyReplyServerPacket.ReplyCodeDataAlreadyInAnotherParty for reply_code " + PartyReplyCode(data._reply_code).name + ".")
-            PartyReplyServerPacket.ReplyCodeDataAlreadyInAnotherParty.serialize(writer, data._reply_code_data)
-        elif data._reply_code == PartyReplyCode.AlreadyInYourParty:
-            if not isinstance(data._reply_code_data, PartyReplyServerPacket.ReplyCodeDataAlreadyInYourParty):
-                raise SerializationError("Expected reply_code_data to be type PartyReplyServerPacket.ReplyCodeDataAlreadyInYourParty for reply_code " + PartyReplyCode(data._reply_code).name + ".")
-            PartyReplyServerPacket.ReplyCodeDataAlreadyInYourParty.serialize(writer, data._reply_code_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._reply_code is None:
+                raise SerializationError("reply_code must be provided.")
+            writer.add_char(int(data._reply_code))
+            if data._reply_code == PartyReplyCode.AlreadyInAnotherParty:
+                if not isinstance(data._reply_code_data, PartyReplyServerPacket.ReplyCodeDataAlreadyInAnotherParty):
+                    raise SerializationError("Expected reply_code_data to be type PartyReplyServerPacket.ReplyCodeDataAlreadyInAnotherParty for reply_code " + PartyReplyCode(data._reply_code).name + ".")
+                PartyReplyServerPacket.ReplyCodeDataAlreadyInAnotherParty.serialize(writer, data._reply_code_data)
+            elif data._reply_code == PartyReplyCode.AlreadyInYourParty:
+                if not isinstance(data._reply_code_data, PartyReplyServerPacket.ReplyCodeDataAlreadyInYourParty):
+                    raise SerializationError("Expected reply_code_data to be type PartyReplyServerPacket.ReplyCodeDataAlreadyInYourParty for reply_code " + PartyReplyCode(data._reply_code).name + ".")
+                PartyReplyServerPacket.ReplyCodeDataAlreadyInYourParty.serialize(writer, data._reply_code_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PartyReplyServerPacket":
@@ -125,10 +132,9 @@ class PartyReplyServerPacket(Packet):
         return f"PartyReplyServerPacket(byte_size={repr(self._byte_size)}, reply_code={repr(self._reply_code)}, reply_code_data={repr(self._reply_code_data)})"
 
     ReplyCodeData = Union['PartyReplyServerPacket.ReplyCodeDataAlreadyInAnotherParty', 'PartyReplyServerPacket.ReplyCodeDataAlreadyInYourParty', None]
-    ReplyCodeData.__doc__ = \
-        """
-        Data associated with different values of the `reply_code` field.
-        """
+    """
+    Data associated with different values of the `reply_code` field.
+    """
 
     class ReplyCodeDataAlreadyInAnotherParty:
         """
@@ -164,9 +170,13 @@ class PartyReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (PartyReplyServerPacket.ReplyCodeDataAlreadyInAnotherParty): The data to serialize.
             """
-            if data._player_name is None:
-                raise SerializationError("player_name must be provided.")
-            writer.add_string(data._player_name)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._player_name is None:
+                    raise SerializationError("player_name must be provided.")
+                writer.add_string(data._player_name)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "PartyReplyServerPacket.ReplyCodeDataAlreadyInAnotherParty":
@@ -226,9 +236,13 @@ class PartyReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (PartyReplyServerPacket.ReplyCodeDataAlreadyInYourParty): The data to serialize.
             """
-            if data._player_name is None:
-                raise SerializationError("player_name must be provided.")
-            writer.add_string(data._player_name)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._player_name is None:
+                    raise SerializationError("player_name must be provided.")
+                writer.add_string(data._player_name)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "PartyReplyServerPacket.ReplyCodeDataAlreadyInYourParty":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class PartyRequestServerPacket(Packet):
+    """
+    Received party invite / join request
+    """
     _byte_size: int = 0
     _request_type: PartyRequestType = None # type: ignore [assignment]
     _inviter_player_id: int = None # type: ignore [assignment]
@@ -97,15 +100,19 @@ class PartyRequestServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PartyRequestServerPacket): The data to serialize.
         """
-        if data._request_type is None:
-            raise SerializationError("request_type must be provided.")
-        writer.add_char(int(data._request_type))
-        if data._inviter_player_id is None:
-            raise SerializationError("inviter_player_id must be provided.")
-        writer.add_short(data._inviter_player_id)
-        if data._player_name is None:
-            raise SerializationError("player_name must be provided.")
-        writer.add_string(data._player_name)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._request_type is None:
+                raise SerializationError("request_type must be provided.")
+            writer.add_char(int(data._request_type))
+            if data._inviter_player_id is None:
+                raise SerializationError("inviter_player_id must be provided.")
+            writer.add_short(data._inviter_player_id)
+            if data._player_name is None:
+                raise SerializationError("player_name must be provided.")
+            writer.add_string(data._player_name)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PartyRequestServerPacket":

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class PartyTargetGroupServerPacket(Packet):
+    """
+    Updated experience and level-ups from party experience
+    """
     _byte_size: int = 0
     _gains: list[PartyExpShare] = None # type: ignore [assignment]
 
@@ -72,10 +75,14 @@ class PartyTargetGroupServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PartyTargetGroupServerPacket): The data to serialize.
         """
-        if data._gains is None:
-            raise SerializationError("gains must be provided.")
-        for i in range(len(data._gains)):
-            PartyExpShare.serialize(writer, data._gains[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._gains is None:
+                raise SerializationError("gains must be provided.")
+            for i in range(len(data._gains)):
+                PartyExpShare.serialize(writer, data._gains[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PartyTargetGroupServerPacket":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class PlayersAgreeServerPacket(Packet):
+    """
+    Player has appeared in nearby view
+    """
     _byte_size: int = 0
     _nearby: NearbyInfo = None # type: ignore [assignment]
 
@@ -71,9 +74,13 @@ class PlayersAgreeServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PlayersAgreeServerPacket): The data to serialize.
         """
-        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:
+            if data._nearby is None:
+                raise SerializationError("nearby must be provided.")
+            NearbyInfo.serialize(writer, data._nearby)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PlayersAgreeServerPacket":

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

@@ -53,18 +53,23 @@ class PlayersList:
             writer (EoWriter): The writer that the data will be serialized to.
             data (PlayersList): The data to serialize.
         """
-        if data._players_count is None:
-            raise SerializationError("players_count must be provided.")
-        writer.add_short(data._players_count)
-        writer.add_byte(0xFF)
-        if data._players is None:
-            raise SerializationError("players must be provided.")
-        if len(data._players) > 64008:
-            raise SerializationError(f"Expected length of players to be 64008 or less, got {len(data._players)}.")
-        for i in range(data._players_count):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._players_count is None:
+                raise SerializationError("players_count must be provided.")
+            writer.add_short(data._players_count)
+            writer.add_byte(0xFF)
+            if data._players is None:
+                raise SerializationError("players must be provided.")
+            if len(data._players) > 64008:
+                raise SerializationError(f"Expected length of players to be 64008 or less, got {len(data._players)}.")
+            for i in range(data._players_count):
+                OnlinePlayer.serialize(writer, data._players[i])
                 writer.add_byte(0xFF)
-            OnlinePlayer.serialize(writer, data._players[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PlayersList":
@@ -87,8 +92,7 @@ class PlayersList:
             data._players = []
             for i in range(data._players_count):
                 data._players.append(OnlinePlayer.deserialize(reader))
-                if i + 1 < data._players_count:
-                    reader.next_chunk()
+                reader.next_chunk()
             reader.chunked_reading_mode = False
             data._byte_size = reader.position - reader_start_position
             return data

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

@@ -53,18 +53,23 @@ class PlayersListFriends:
             writer (EoWriter): The writer that the data will be serialized to.
             data (PlayersListFriends): The data to serialize.
         """
-        if data._players_count is None:
-            raise SerializationError("players_count must be provided.")
-        writer.add_short(data._players_count)
-        writer.add_byte(0xFF)
-        if data._players is None:
-            raise SerializationError("players must be provided.")
-        if len(data._players) > 64008:
-            raise SerializationError(f"Expected length of players to be 64008 or less, got {len(data._players)}.")
-        for i in range(data._players_count):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._players_count is None:
+                raise SerializationError("players_count must be provided.")
+            writer.add_short(data._players_count)
+            writer.add_byte(0xFF)
+            if data._players is None:
+                raise SerializationError("players must be provided.")
+            if len(data._players) > 64008:
+                raise SerializationError(f"Expected length of players to be 64008 or less, got {len(data._players)}.")
+            for i in range(data._players_count):
+                writer.add_string(data._players[i])
                 writer.add_byte(0xFF)
-            writer.add_string(data._players[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PlayersListFriends":
@@ -87,8 +92,7 @@ class PlayersListFriends:
             data._players = []
             for i in range(data._players_count):
                 data._players.append(reader.get_string())
-                if i + 1 < data._players_count:
-                    reader.next_chunk()
+                reader.next_chunk()
             reader.chunked_reading_mode = False
             data._byte_size = reader.position - reader_start_position
             return data

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class PlayersListServerPacket(Packet):
+    """
+    Equivalent to INIT_INIT with InitReply.PlayersList
+    """
     _byte_size: int = 0
     _players_list: PlayersList = None # type: ignore [assignment]
 
@@ -71,9 +74,15 @@ class PlayersListServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PlayersListServerPacket): The data to serialize.
         """
-        if data._players_list is None:
-            raise SerializationError("players_list must be provided.")
-        PlayersList.serialize(writer, data._players_list)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._players_list is None:
+                raise SerializationError("players_list must be provided.")
+            PlayersList.serialize(writer, data._players_list)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PlayersListServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class PlayersNet242ServerPacket(Packet):
+    """
+    #find command reply - different map
+    """
     _byte_size: int = 0
     _name: str = None # type: ignore [assignment]
 
@@ -70,9 +73,13 @@ class PlayersNet242ServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PlayersNet242ServerPacket): The data to serialize.
         """
-        if data._name is None:
-            raise SerializationError("name must be provided.")
-        writer.add_string(data._name)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._name is None:
+                raise SerializationError("name must be provided.")
+            writer.add_string(data._name)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PlayersNet242ServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class PlayersPingServerPacket(Packet):
+    """
+    #find command reply - offline
+    """
     _byte_size: int = 0
     _name: str = None # type: ignore [assignment]
 
@@ -70,9 +73,13 @@ class PlayersPingServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PlayersPingServerPacket): The data to serialize.
         """
-        if data._name is None:
-            raise SerializationError("name must be provided.")
-        writer.add_string(data._name)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._name is None:
+                raise SerializationError("name must be provided.")
+            writer.add_string(data._name)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PlayersPingServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class PlayersPongServerPacket(Packet):
+    """
+    #find command reply - same map
+    """
     _byte_size: int = 0
     _name: str = None # type: ignore [assignment]
 
@@ -70,9 +73,13 @@ class PlayersPongServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PlayersPongServerPacket): The data to serialize.
         """
-        if data._name is None:
-            raise SerializationError("name must be provided.")
-        writer.add_string(data._name)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._name is None:
+                raise SerializationError("name must be provided.")
+            writer.add_string(data._name)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PlayersPongServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class PlayersRemoveServerPacket(Packet):
+    """
+    Nearby player has logged out
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
 
@@ -78,9 +81,13 @@ class PlayersRemoveServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PlayersRemoveServerPacket): The data to serialize.
         """
-        if data._player_id is None:
-            raise SerializationError("player_id must be provided.")
-        writer.add_short(data._player_id)
+        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)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PlayersRemoveServerPacket":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class PlayersReplyServerPacket(Packet):
+    """
+    Equivalent to INIT_INIT with InitReply.PlayersListFriends
+    """
     _byte_size: int = 0
     _players_list: PlayersListFriends = None # type: ignore [assignment]
 
@@ -71,9 +74,15 @@ class PlayersReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PlayersReplyServerPacket): The data to serialize.
         """
-        if data._players_list is None:
-            raise SerializationError("players_list must be provided.")
-        PlayersListFriends.serialize(writer, data._players_list)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._players_list is None:
+                raise SerializationError("players_list must be provided.")
+            PlayersListFriends.serialize(writer, data._players_list)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PlayersReplyServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class PriestOpenServerPacket(Packet):
+    """
+    Response from talking to a priest NPC
+    """
     _byte_size: int = 0
     _session_id: int = None # type: ignore [assignment]
 
@@ -78,9 +81,13 @@ class PriestOpenServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PriestOpenServerPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_int(data._session_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_int(data._session_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PriestOpenServerPacket":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class PriestReplyServerPacket(Packet):
+    """
+    Reply to client Priest-family packets
+    """
     _byte_size: int = 0
     _reply_code: PriestReply = None # type: ignore [assignment]
 
@@ -71,9 +74,13 @@ class PriestReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PriestReplyServerPacket): The data to serialize.
         """
-        if data._reply_code is None:
-            raise SerializationError("reply_code must be provided.")
-        writer.add_short(int(data._reply_code))
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._reply_code is None:
+                raise SerializationError("reply_code must be provided.")
+            writer.add_short(int(data._reply_code))
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PriestReplyServerPacket":