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

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

@@ -178,27 +178,31 @@ class SpellTargetOtherServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellTargetOtherServerPacket): The data to serialize.
         """
-        if data._victim_id is None:
-            raise SerializationError("victim_id must be provided.")
-        writer.add_short(data._victim_id)
-        if data._caster_id is None:
-            raise SerializationError("caster_id must be provided.")
-        writer.add_short(data._caster_id)
-        if data._caster_direction is None:
-            raise SerializationError("caster_direction must be provided.")
-        writer.add_char(int(data._caster_direction))
-        if data._spell_id is None:
-            raise SerializationError("spell_id must be provided.")
-        writer.add_short(data._spell_id)
-        if data._spell_heal_hp is None:
-            raise SerializationError("spell_heal_hp must be provided.")
-        writer.add_int(data._spell_heal_hp)
-        if data._hp_percentage is None:
-            raise SerializationError("hp_percentage must be provided.")
-        writer.add_char(data._hp_percentage)
-        reached_missing_optional = data._hp is None
-        if not reached_missing_optional:
-            writer.add_short(cast(int, data._hp))
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._victim_id is None:
+                raise SerializationError("victim_id must be provided.")
+            writer.add_short(data._victim_id)
+            if data._caster_id is None:
+                raise SerializationError("caster_id must be provided.")
+            writer.add_short(data._caster_id)
+            if data._caster_direction is None:
+                raise SerializationError("caster_direction must be provided.")
+            writer.add_char(int(data._caster_direction))
+            if data._spell_id is None:
+                raise SerializationError("spell_id must be provided.")
+            writer.add_short(data._spell_id)
+            if data._spell_heal_hp is None:
+                raise SerializationError("spell_heal_hp must be provided.")
+            writer.add_int(data._spell_heal_hp)
+            if data._hp_percentage is None:
+                raise SerializationError("hp_percentage must be provided.")
+            writer.add_char(data._hp_percentage)
+            reached_missing_optional = data._hp is None
+            if not reached_missing_optional:
+                writer.add_short(cast(int, data._hp))
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SpellTargetOtherServerPacket":

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

@@ -176,24 +176,28 @@ class SpellTargetSelfServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellTargetSelfServerPacket): 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._spell_id is None:
-            raise SerializationError("spell_id must be provided.")
-        writer.add_short(data._spell_id)
-        if data._spell_heal_hp is None:
-            raise SerializationError("spell_heal_hp must be provided.")
-        writer.add_int(data._spell_heal_hp)
-        if data._hp_percentage is None:
-            raise SerializationError("hp_percentage must be provided.")
-        writer.add_char(data._hp_percentage)
-        reached_missing_optional = data._hp is None
-        if not reached_missing_optional:
-            writer.add_short(cast(int, data._hp))
-        reached_missing_optional = reached_missing_optional or data._tp is None
-        if not reached_missing_optional:
-            writer.add_short(cast(int, data._tp))
+        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._spell_id is None:
+                raise SerializationError("spell_id must be provided.")
+            writer.add_short(data._spell_id)
+            if data._spell_heal_hp is None:
+                raise SerializationError("spell_heal_hp must be provided.")
+            writer.add_int(data._spell_heal_hp)
+            if data._hp_percentage is None:
+                raise SerializationError("hp_percentage must be provided.")
+            writer.add_char(data._hp_percentage)
+            reached_missing_optional = data._hp is None
+            if not reached_missing_optional:
+                writer.add_short(cast(int, data._hp))
+            reached_missing_optional = reached_missing_optional or data._tp is None
+            if not reached_missing_optional:
+                writer.add_short(cast(int, data._tp))
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SpellTargetSelfServerPacket":

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

@@ -91,12 +91,16 @@ class StatSkillAcceptServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (StatSkillAcceptServerPacket): The data to serialize.
         """
-        if data._skill_points is None:
-            raise SerializationError("skill_points must be provided.")
-        writer.add_short(data._skill_points)
-        if data._spell is None:
-            raise SerializationError("spell must be provided.")
-        Spell.serialize(writer, data._spell)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._skill_points is None:
+                raise SerializationError("skill_points must be provided.")
+            writer.add_short(data._skill_points)
+            if data._spell is None:
+                raise SerializationError("spell must be provided.")
+            Spell.serialize(writer, data._spell)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "StatSkillAcceptServerPacket":

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

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

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

@@ -101,17 +101,23 @@ class StatSkillOpenServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (StatSkillOpenServerPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_short(data._session_id)
-        if data._shop_name is None:
-            raise SerializationError("shop_name must be provided.")
-        writer.add_string(data._shop_name)
-        writer.add_byte(0xFF)
-        if data._skills is None:
-            raise SerializationError("skills must be provided.")
-        for i in range(len(data._skills)):
-            SkillLearn.serialize(writer, data._skills[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_short(data._session_id)
+            if data._shop_name is None:
+                raise SerializationError("shop_name must be provided.")
+            writer.add_string(data._shop_name)
+            writer.add_byte(0xFF)
+            if data._skills is None:
+                raise SerializationError("skills must be provided.")
+            for i in range(len(data._skills)):
+                SkillLearn.serialize(writer, data._skills[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "StatSkillOpenServerPacket":

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

@@ -91,12 +91,16 @@ class StatSkillPlayerServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (StatSkillPlayerServerPacket): The data to serialize.
         """
-        if data._stat_points is None:
-            raise SerializationError("stat_points must be provided.")
-        writer.add_short(data._stat_points)
-        if data._stats is None:
-            raise SerializationError("stats must be provided.")
-        CharacterStatsUpdate.serialize(writer, data._stats)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._stat_points is None:
+                raise SerializationError("stat_points must be provided.")
+            writer.add_short(data._stat_points)
+            if data._stats is None:
+                raise SerializationError("stats must be provided.")
+            CharacterStatsUpdate.serialize(writer, data._stats)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "StatSkillPlayerServerPacket":

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

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

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

@@ -87,13 +87,17 @@ class StatSkillReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (StatSkillReplyServerPacket): The data to serialize.
         """
-        if data._reply_code is None:
-            raise SerializationError("reply_code must be provided.")
-        writer.add_short(int(data._reply_code))
-        if data._reply_code == SkillMasterReply.WrongClass:
-            if not isinstance(data._reply_code_data, StatSkillReplyServerPacket.ReplyCodeDataWrongClass):
-                raise SerializationError("Expected reply_code_data to be type StatSkillReplyServerPacket.ReplyCodeDataWrongClass for reply_code " + SkillMasterReply(data._reply_code).name + ".")
-            StatSkillReplyServerPacket.ReplyCodeDataWrongClass.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_short(int(data._reply_code))
+            if data._reply_code == SkillMasterReply.WrongClass:
+                if not isinstance(data._reply_code_data, StatSkillReplyServerPacket.ReplyCodeDataWrongClass):
+                    raise SerializationError("Expected reply_code_data to be type StatSkillReplyServerPacket.ReplyCodeDataWrongClass for reply_code " + SkillMasterReply(data._reply_code).name + ".")
+                StatSkillReplyServerPacket.ReplyCodeDataWrongClass.serialize(writer, data._reply_code_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "StatSkillReplyServerPacket":
@@ -122,10 +126,9 @@ class StatSkillReplyServerPacket(Packet):
         return f"StatSkillReplyServerPacket(byte_size={repr(self._byte_size)}, reply_code={repr(self._reply_code)}, reply_code_data={repr(self._reply_code_data)})"
 
     ReplyCodeData = Union['StatSkillReplyServerPacket.ReplyCodeDataWrongClass', None]
-    ReplyCodeData.__doc__ = \
-        """
-        Data associated with different values of the `reply_code` field.
-        """
+    """
+    Data associated with different values of the `reply_code` field.
+    """
 
     class ReplyCodeDataWrongClass:
         """
@@ -169,9 +172,13 @@ class StatSkillReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (StatSkillReplyServerPacket.ReplyCodeDataWrongClass): The data to serialize.
             """
-            if data._class_id is None:
-                raise SerializationError("class_id must be provided.")
-            writer.add_char(data._class_id)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._class_id is None:
+                    raise SerializationError("class_id must be provided.")
+                writer.add_char(data._class_id)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "StatSkillReplyServerPacket.ReplyCodeDataWrongClass":

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

@@ -98,12 +98,16 @@ class StatSkillTakeServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (StatSkillTakeServerPacket): The data to serialize.
         """
-        if data._spell_id is None:
-            raise SerializationError("spell_id must be provided.")
-        writer.add_short(data._spell_id)
-        if data._gold_amount is None:
-            raise SerializationError("gold_amount must be provided.")
-        writer.add_int(data._gold_amount)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._spell_id is None:
+                raise SerializationError("spell_id must be provided.")
+            writer.add_short(data._spell_id)
+            if data._gold_amount is None:
+                raise SerializationError("gold_amount must be provided.")
+            writer.add_int(data._gold_amount)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "StatSkillTakeServerPacket":

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

@@ -82,13 +82,19 @@ class TalkAdminServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkAdminServerPacket): The data to serialize.
         """
-        if data._player_name is None:
-            raise SerializationError("player_name must be provided.")
-        writer.add_string(data._player_name)
-        writer.add_byte(0xFF)
-        if data._message is None:
-            raise SerializationError("message must be provided.")
-        writer.add_string(data._message)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._player_name is None:
+                raise SerializationError("player_name must be provided.")
+            writer.add_string(data._player_name)
+            writer.add_byte(0xFF)
+            if data._message is None:
+                raise SerializationError("message must be provided.")
+            writer.add_string(data._message)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TalkAdminServerPacket":

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

@@ -82,13 +82,19 @@ class TalkAnnounceServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkAnnounceServerPacket): The data to serialize.
         """
-        if data._player_name is None:
-            raise SerializationError("player_name must be provided.")
-        writer.add_string(data._player_name)
-        writer.add_byte(0xFF)
-        if data._message is None:
-            raise SerializationError("message must be provided.")
-        writer.add_string(data._message)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._player_name is None:
+                raise SerializationError("player_name must be provided.")
+            writer.add_string(data._player_name)
+            writer.add_byte(0xFF)
+            if data._message is None:
+                raise SerializationError("message must be provided.")
+            writer.add_string(data._message)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TalkAnnounceServerPacket":

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

@@ -76,12 +76,17 @@ class TalkListServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkListServerPacket): The data to serialize.
         """
-        if data._messages is None:
-            raise SerializationError("messages must be provided.")
-        for i in range(len(data._messages)):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._messages is None:
+                raise SerializationError("messages must be provided.")
+            for i in range(len(data._messages)):
+                GlobalBackfillMessage.serialize(writer, data._messages[i])
                 writer.add_byte(0xFF)
-            GlobalBackfillMessage.serialize(writer, data._messages[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TalkListServerPacket":

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

@@ -82,13 +82,19 @@ class TalkMsgServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkMsgServerPacket): The data to serialize.
         """
-        if data._player_name is None:
-            raise SerializationError("player_name must be provided.")
-        writer.add_string(data._player_name)
-        writer.add_byte(0xFF)
-        if data._message is None:
-            raise SerializationError("message must be provided.")
-        writer.add_string(data._message)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._player_name is None:
+                raise SerializationError("player_name must be provided.")
+            writer.add_string(data._player_name)
+            writer.add_byte(0xFF)
+            if data._message is None:
+                raise SerializationError("message must be provided.")
+            writer.add_string(data._message)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TalkMsgServerPacket":

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

@@ -90,12 +90,16 @@ class TalkOpenServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkOpenServerPacket): 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._message is None:
-            raise SerializationError("message must be provided.")
-        writer.add_string(data._message)
+        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._message is None:
+                raise SerializationError("message must be provided.")
+            writer.add_string(data._message)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TalkOpenServerPacket":

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

@@ -90,12 +90,16 @@ class TalkPlayerServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkPlayerServerPacket): 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._message is None:
-            raise SerializationError("message must be provided.")
-        writer.add_string(data._message)
+        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._message is None:
+                raise SerializationError("message must be provided.")
+            writer.add_string(data._message)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TalkPlayerServerPacket":

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

@@ -83,12 +83,16 @@ class TalkReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkReplyServerPacket): The data to serialize.
         """
-        if data._reply_code is None:
-            raise SerializationError("reply_code must be provided.")
-        writer.add_short(int(data._reply_code))
-        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._reply_code is None:
+                raise SerializationError("reply_code must be provided.")
+            writer.add_short(int(data._reply_code))
+            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) -> "TalkReplyServerPacket":

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

@@ -82,13 +82,19 @@ class TalkRequestServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkRequestServerPacket): The data to serialize.
         """
-        if data._player_name is None:
-            raise SerializationError("player_name must be provided.")
-        writer.add_string(data._player_name)
-        writer.add_byte(0xFF)
-        if data._message is None:
-            raise SerializationError("message must be provided.")
-        writer.add_string(data._message)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._player_name is None:
+                raise SerializationError("player_name must be provided.")
+            writer.add_string(data._player_name)
+            writer.add_byte(0xFF)
+            if data._message is None:
+                raise SerializationError("message must be provided.")
+            writer.add_string(data._message)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TalkRequestServerPacket":

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

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

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

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

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

@@ -82,13 +82,19 @@ class TalkTellServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkTellServerPacket): The data to serialize.
         """
-        if data._player_name is None:
-            raise SerializationError("player_name must be provided.")
-        writer.add_string(data._player_name)
-        writer.add_byte(0xFF)
-        if data._message is None:
-            raise SerializationError("message must be provided.")
-        writer.add_string(data._message)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._player_name is None:
+                raise SerializationError("player_name must be provided.")
+            writer.add_string(data._player_name)
+            writer.add_byte(0xFF)
+            if data._message is None:
+                raise SerializationError("message must be provided.")
+            writer.add_string(data._message)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TalkTellServerPacket":

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

@@ -74,9 +74,13 @@ class TradeAdminServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TradeAdminServerPacket): 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) -> "TradeAdminServerPacket":

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

@@ -90,12 +90,16 @@ class TradeAgreeServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TradeAgreeServerPacket): 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._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._partner_player_id is None:
+                raise SerializationError("partner_player_id must be provided.")
+            writer.add_short(data._partner_player_id)
+            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) -> "TradeAgreeServerPacket":