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

eolib/protocol/_generated/net/client/spell_target_other_client_packet.py

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class SpellTargetOtherClientPacket(Packet):
+    """
+    Targeted spell cast
+    """
     _byte_size: int = 0
     _target_type: SpellTargetType = None # type: ignore [assignment]
     _previous_timestamp: int = None # type: ignore [assignment]
@@ -139,21 +142,25 @@ class SpellTargetOtherClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellTargetOtherClientPacket): The data to serialize.
         """
-        if data._target_type is None:
-            raise SerializationError("target_type must be provided.")
-        writer.add_char(int(data._target_type))
-        if data._previous_timestamp is None:
-            raise SerializationError("previous_timestamp must be provided.")
-        writer.add_three(data._previous_timestamp)
-        if data._spell_id is None:
-            raise SerializationError("spell_id must be provided.")
-        writer.add_short(data._spell_id)
-        if data._victim_id is None:
-            raise SerializationError("victim_id must be provided.")
-        writer.add_short(data._victim_id)
-        if data._timestamp is None:
-            raise SerializationError("timestamp must be provided.")
-        writer.add_three(data._timestamp)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._target_type is None:
+                raise SerializationError("target_type must be provided.")
+            writer.add_char(int(data._target_type))
+            if data._previous_timestamp is None:
+                raise SerializationError("previous_timestamp must be provided.")
+            writer.add_three(data._previous_timestamp)
+            if data._spell_id is None:
+                raise SerializationError("spell_id must be provided.")
+            writer.add_short(data._spell_id)
+            if data._victim_id is None:
+                raise SerializationError("victim_id must be provided.")
+            writer.add_short(data._victim_id)
+            if data._timestamp is None:
+                raise SerializationError("timestamp must be provided.")
+            writer.add_three(data._timestamp)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SpellTargetOtherClientPacket":

eolib/protocol/_generated/net/client/spell_target_self_client_packet.py

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class SpellTargetSelfClientPacket(Packet):
+    """
+    Self-targeted spell cast
+    """
     _byte_size: int = 0
     _direction: Direction = None # type: ignore [assignment]
     _spell_id: int = None # type: ignore [assignment]
@@ -105,15 +108,19 @@ class SpellTargetSelfClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellTargetSelfClientPacket): The data to serialize.
         """
-        if data._direction is None:
-            raise SerializationError("direction must be provided.")
-        writer.add_char(int(data._direction))
-        if data._spell_id is None:
-            raise SerializationError("spell_id must be provided.")
-        writer.add_short(data._spell_id)
-        if data._timestamp is None:
-            raise SerializationError("timestamp must be provided.")
-        writer.add_three(data._timestamp)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._direction is None:
+                raise SerializationError("direction must be provided.")
+            writer.add_char(int(data._direction))
+            if data._spell_id is None:
+                raise SerializationError("spell_id must be provided.")
+            writer.add_short(data._spell_id)
+            if data._timestamp is None:
+                raise SerializationError("timestamp must be provided.")
+            writer.add_three(data._timestamp)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SpellTargetSelfClientPacket":

eolib/protocol/_generated/net/client/spell_use_client_packet.py

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class SpellUseClientPacket(Packet):
+    """
+    Raise arm to cast a spell (vestigial)
+    """
     _byte_size: int = 0
     _direction: Direction = None # type: ignore [assignment]
 
@@ -71,9 +74,13 @@ class SpellUseClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellUseClientPacket): The data to serialize.
         """
-        if data._direction is None:
-            raise SerializationError("direction must be provided.")
-        writer.add_char(int(data._direction))
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._direction is None:
+                raise SerializationError("direction must be provided.")
+            writer.add_char(int(data._direction))
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SpellUseClientPacket":

eolib/protocol/_generated/net/client/stat_skill_add_client_packet.py

@@ -14,6 +14,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class StatSkillAddClientPacket(Packet):
+    """
+    Spending a stat point on a stat or skill
+    """
     _byte_size: int = 0
     _action_type: TrainType = None # type: ignore [assignment]
     _action_type_data: 'StatSkillAddClientPacket.ActionTypeData' = None
@@ -85,17 +88,21 @@ class StatSkillAddClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (StatSkillAddClientPacket): The data to serialize.
         """
-        if data._action_type is None:
-            raise SerializationError("action_type must be provided.")
-        writer.add_char(int(data._action_type))
-        if data._action_type == TrainType.Stat:
-            if not isinstance(data._action_type_data, StatSkillAddClientPacket.ActionTypeDataStat):
-                raise SerializationError("Expected action_type_data to be type StatSkillAddClientPacket.ActionTypeDataStat for action_type " + TrainType(data._action_type).name + ".")
-            StatSkillAddClientPacket.ActionTypeDataStat.serialize(writer, data._action_type_data)
-        elif data._action_type == TrainType.Skill:
-            if not isinstance(data._action_type_data, StatSkillAddClientPacket.ActionTypeDataSkill):
-                raise SerializationError("Expected action_type_data to be type StatSkillAddClientPacket.ActionTypeDataSkill for action_type " + TrainType(data._action_type).name + ".")
-            StatSkillAddClientPacket.ActionTypeDataSkill.serialize(writer, data._action_type_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._action_type is None:
+                raise SerializationError("action_type must be provided.")
+            writer.add_char(int(data._action_type))
+            if data._action_type == TrainType.Stat:
+                if not isinstance(data._action_type_data, StatSkillAddClientPacket.ActionTypeDataStat):
+                    raise SerializationError("Expected action_type_data to be type StatSkillAddClientPacket.ActionTypeDataStat for action_type " + TrainType(data._action_type).name + ".")
+                StatSkillAddClientPacket.ActionTypeDataStat.serialize(writer, data._action_type_data)
+            elif data._action_type == TrainType.Skill:
+                if not isinstance(data._action_type_data, StatSkillAddClientPacket.ActionTypeDataSkill):
+                    raise SerializationError("Expected action_type_data to be type StatSkillAddClientPacket.ActionTypeDataSkill for action_type " + TrainType(data._action_type).name + ".")
+                StatSkillAddClientPacket.ActionTypeDataSkill.serialize(writer, data._action_type_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "StatSkillAddClientPacket":
@@ -126,10 +133,9 @@ class StatSkillAddClientPacket(Packet):
         return f"StatSkillAddClientPacket(byte_size={repr(self._byte_size)}, action_type={repr(self._action_type)}, action_type_data={repr(self._action_type_data)})"
 
     ActionTypeData = Union['StatSkillAddClientPacket.ActionTypeDataStat', 'StatSkillAddClientPacket.ActionTypeDataSkill', None]
-    ActionTypeData.__doc__ = \
-        """
-        Data associated with different values of the `action_type` field.
-        """
+    """
+    Data associated with different values of the `action_type` field.
+    """
 
     class ActionTypeDataStat:
         """
@@ -165,9 +171,13 @@ class StatSkillAddClientPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (StatSkillAddClientPacket.ActionTypeDataStat): The data to serialize.
             """
-            if data._stat_id is None:
-                raise SerializationError("stat_id must be provided.")
-            writer.add_short(int(data._stat_id))
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._stat_id is None:
+                    raise SerializationError("stat_id must be provided.")
+                writer.add_short(int(data._stat_id))
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "StatSkillAddClientPacket.ActionTypeDataStat":
@@ -235,9 +245,13 @@ class StatSkillAddClientPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (StatSkillAddClientPacket.ActionTypeDataSkill): 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) -> "StatSkillAddClientPacket.ActionTypeDataSkill":

eolib/protocol/_generated/net/client/stat_skill_junk_client_packet.py

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class StatSkillJunkClientPacket(Packet):
+    """
+    Resetting stats at a skill master
+    """
     _byte_size: int = 0
     _session_id: int = None # type: ignore [assignment]
 
@@ -78,9 +81,13 @@ class StatSkillJunkClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (StatSkillJunkClientPacket): 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) -> "StatSkillJunkClientPacket":

eolib/protocol/_generated/net/client/stat_skill_open_client_packet.py

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

eolib/protocol/_generated/net/client/stat_skill_remove_client_packet.py

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class StatSkillRemoveClientPacket(Packet):
+    """
+    Forgetting a skill at a skill master NPC
+    """
     _byte_size: int = 0
     _session_id: int = None # type: ignore [assignment]
     _spell_id: int = None # type: ignore [assignment]
@@ -95,12 +98,16 @@ class StatSkillRemoveClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (StatSkillRemoveClientPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_int(data._session_id)
-        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._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_int(data._session_id)
+            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) -> "StatSkillRemoveClientPacket":

eolib/protocol/_generated/net/client/stat_skill_take_client_packet.py

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class StatSkillTakeClientPacket(Packet):
+    """
+    Learning a skill from a skill master NPC
+    """
     _byte_size: int = 0
     _session_id: int = None # type: ignore [assignment]
     _spell_id: int = None # type: ignore [assignment]
@@ -95,12 +98,16 @@ class StatSkillTakeClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (StatSkillTakeClientPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_int(data._session_id)
-        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._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_int(data._session_id)
+            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) -> "StatSkillTakeClientPacket":

eolib/protocol/_generated/net/client/talk_admin_client_packet.py

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TalkAdminClientPacket(Packet):
+    """
+    Admin chat message
+    """
     _byte_size: int = 0
     _message: str = None # type: ignore [assignment]
 
@@ -70,9 +73,13 @@ class TalkAdminClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkAdminClientPacket): 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) -> "TalkAdminClientPacket":

eolib/protocol/_generated/net/client/talk_announce_client_packet.py

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TalkAnnounceClientPacket(Packet):
+    """
+    Admin announcement
+    """
     _byte_size: int = 0
     _message: str = None # type: ignore [assignment]
 
@@ -70,9 +73,13 @@ class TalkAnnounceClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkAnnounceClientPacket): 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) -> "TalkAnnounceClientPacket":

eolib/protocol/_generated/net/client/talk_msg_client_packet.py

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TalkMsgClientPacket(Packet):
+    """
+    Global chat message
+    """
     _byte_size: int = 0
     _message: str = None # type: ignore [assignment]
 
@@ -70,9 +73,13 @@ class TalkMsgClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkMsgClientPacket): 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) -> "TalkMsgClientPacket":

eolib/protocol/_generated/net/client/talk_open_client_packet.py

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TalkOpenClientPacket(Packet):
+    """
+    Party chat message
+    """
     _byte_size: int = 0
     _message: str = None # type: ignore [assignment]
 
@@ -70,9 +73,13 @@ class TalkOpenClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkOpenClientPacket): 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) -> "TalkOpenClientPacket":

eolib/protocol/_generated/net/client/talk_player_client_packet.py

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TalkPlayerClientPacket(Packet):
+    """
+    Public chat message - alias of TALK_REPORT (vestigial)
+    """
     _byte_size: int = 0
     _message: str = None # type: ignore [assignment]
 
@@ -70,9 +73,13 @@ class TalkPlayerClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkPlayerClientPacket): 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) -> "TalkPlayerClientPacket":

eolib/protocol/_generated/net/client/talk_report_client_packet.py

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TalkReportClientPacket(Packet):
+    """
+    Public chat message
+    """
     _byte_size: int = 0
     _message: str = None # type: ignore [assignment]
 
@@ -70,9 +73,13 @@ class TalkReportClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkReportClientPacket): 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) -> "TalkReportClientPacket":

eolib/protocol/_generated/net/client/talk_request_client_packet.py

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TalkRequestClientPacket(Packet):
+    """
+    Guild chat message
+    """
     _byte_size: int = 0
     _message: str = None # type: ignore [assignment]
 
@@ -70,9 +73,13 @@ class TalkRequestClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkRequestClientPacket): 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) -> "TalkRequestClientPacket":

eolib/protocol/_generated/net/client/talk_tell_client_packet.py

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TalkTellClientPacket(Packet):
+    """
+    Private chat message
+    """
     _byte_size: int = 0
     _name: str = None # type: ignore [assignment]
     _message: str = None # type: ignore [assignment]
@@ -79,13 +82,19 @@ class TalkTellClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkTellClientPacket): The data to serialize.
         """
-        if data._name is None:
-            raise SerializationError("name must be provided.")
-        writer.add_string(data._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._name is None:
+                raise SerializationError("name must be provided.")
+            writer.add_string(data._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) -> "TalkTellClientPacket":

eolib/protocol/_generated/net/client/talk_use_client_packet.py

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TalkUseClientPacket(Packet):
+    """
+    Public chat message - alias of TALK_REPORT (vestigial)
+    """
     _byte_size: int = 0
     _message: str = None # type: ignore [assignment]
 
@@ -70,9 +73,13 @@ class TalkUseClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkUseClientPacket): 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) -> "TalkUseClientPacket":

eolib/protocol/_generated/net/client/trade_accept_client_packet.py

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TradeAcceptClientPacket(Packet):
+    """
+    Accepting a trade request
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
 
@@ -78,10 +81,14 @@ class TradeAcceptClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TradeAcceptClientPacket): The data to serialize.
         """
-        writer.add_char(0)
-        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:
+            writer.add_char(0)
+            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) -> "TradeAcceptClientPacket":