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

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class AccountReplyServerPacket(Packet):
+    """
+    Reply to client Account-family packets
+    """
     _byte_size: int = 0
     _reply_code: AccountReply = None # type: ignore [assignment]
     _reply_code_data: 'AccountReplyServerPacket.ReplyCodeData' = None
@@ -90,49 +93,53 @@ class AccountReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (AccountReplyServerPacket): 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 == 0:
-            if data._reply_code_data is not None:
-                raise SerializationError("Expected reply_code_data to be None for reply_code " + AccountReply(data._reply_code).name + ".")
-        elif data._reply_code == AccountReply.Exists:
-            if not isinstance(data._reply_code_data, AccountReplyServerPacket.ReplyCodeDataExists):
-                raise SerializationError("Expected reply_code_data to be type AccountReplyServerPacket.ReplyCodeDataExists for reply_code " + AccountReply(data._reply_code).name + ".")
-            AccountReplyServerPacket.ReplyCodeDataExists.serialize(writer, data._reply_code_data)
-        elif data._reply_code == AccountReply.NotApproved:
-            if not isinstance(data._reply_code_data, AccountReplyServerPacket.ReplyCodeDataNotApproved):
-                raise SerializationError("Expected reply_code_data to be type AccountReplyServerPacket.ReplyCodeDataNotApproved for reply_code " + AccountReply(data._reply_code).name + ".")
-            AccountReplyServerPacket.ReplyCodeDataNotApproved.serialize(writer, data._reply_code_data)
-        elif data._reply_code == AccountReply.Created:
-            if not isinstance(data._reply_code_data, AccountReplyServerPacket.ReplyCodeDataCreated):
-                raise SerializationError("Expected reply_code_data to be type AccountReplyServerPacket.ReplyCodeDataCreated for reply_code " + AccountReply(data._reply_code).name + ".")
-            AccountReplyServerPacket.ReplyCodeDataCreated.serialize(writer, data._reply_code_data)
-        elif data._reply_code == 4:
-            if data._reply_code_data is not None:
-                raise SerializationError("Expected reply_code_data to be None for reply_code " + AccountReply(data._reply_code).name + ".")
-        elif data._reply_code == AccountReply.ChangeFailed:
-            if not isinstance(data._reply_code_data, AccountReplyServerPacket.ReplyCodeDataChangeFailed):
-                raise SerializationError("Expected reply_code_data to be type AccountReplyServerPacket.ReplyCodeDataChangeFailed for reply_code " + AccountReply(data._reply_code).name + ".")
-            AccountReplyServerPacket.ReplyCodeDataChangeFailed.serialize(writer, data._reply_code_data)
-        elif data._reply_code == AccountReply.Changed:
-            if not isinstance(data._reply_code_data, AccountReplyServerPacket.ReplyCodeDataChanged):
-                raise SerializationError("Expected reply_code_data to be type AccountReplyServerPacket.ReplyCodeDataChanged for reply_code " + AccountReply(data._reply_code).name + ".")
-            AccountReplyServerPacket.ReplyCodeDataChanged.serialize(writer, data._reply_code_data)
-        elif data._reply_code == AccountReply.RequestDenied:
-            if not isinstance(data._reply_code_data, AccountReplyServerPacket.ReplyCodeDataRequestDenied):
-                raise SerializationError("Expected reply_code_data to be type AccountReplyServerPacket.ReplyCodeDataRequestDenied for reply_code " + AccountReply(data._reply_code).name + ".")
-            AccountReplyServerPacket.ReplyCodeDataRequestDenied.serialize(writer, data._reply_code_data)
-        elif data._reply_code == 8:
-            if data._reply_code_data is not None:
-                raise SerializationError("Expected reply_code_data to be None for reply_code " + AccountReply(data._reply_code).name + ".")
-        elif data._reply_code == 9:
-            if data._reply_code_data is not None:
-                raise SerializationError("Expected reply_code_data to be None for reply_code " + AccountReply(data._reply_code).name + ".")
-        else:
-            if not isinstance(data._reply_code_data, AccountReplyServerPacket.ReplyCodeDataDefault):
-                raise SerializationError("Expected reply_code_data to be type AccountReplyServerPacket.ReplyCodeDataDefault for reply_code " + AccountReply(data._reply_code).name + ".")
-            AccountReplyServerPacket.ReplyCodeDataDefault.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 == 0:
+                if data._reply_code_data is not None:
+                    raise SerializationError("Expected reply_code_data to be None for reply_code " + AccountReply(data._reply_code).name + ".")
+            elif data._reply_code == AccountReply.Exists:
+                if not isinstance(data._reply_code_data, AccountReplyServerPacket.ReplyCodeDataExists):
+                    raise SerializationError("Expected reply_code_data to be type AccountReplyServerPacket.ReplyCodeDataExists for reply_code " + AccountReply(data._reply_code).name + ".")
+                AccountReplyServerPacket.ReplyCodeDataExists.serialize(writer, data._reply_code_data)
+            elif data._reply_code == AccountReply.NotApproved:
+                if not isinstance(data._reply_code_data, AccountReplyServerPacket.ReplyCodeDataNotApproved):
+                    raise SerializationError("Expected reply_code_data to be type AccountReplyServerPacket.ReplyCodeDataNotApproved for reply_code " + AccountReply(data._reply_code).name + ".")
+                AccountReplyServerPacket.ReplyCodeDataNotApproved.serialize(writer, data._reply_code_data)
+            elif data._reply_code == AccountReply.Created:
+                if not isinstance(data._reply_code_data, AccountReplyServerPacket.ReplyCodeDataCreated):
+                    raise SerializationError("Expected reply_code_data to be type AccountReplyServerPacket.ReplyCodeDataCreated for reply_code " + AccountReply(data._reply_code).name + ".")
+                AccountReplyServerPacket.ReplyCodeDataCreated.serialize(writer, data._reply_code_data)
+            elif data._reply_code == 4:
+                if data._reply_code_data is not None:
+                    raise SerializationError("Expected reply_code_data to be None for reply_code " + AccountReply(data._reply_code).name + ".")
+            elif data._reply_code == AccountReply.ChangeFailed:
+                if not isinstance(data._reply_code_data, AccountReplyServerPacket.ReplyCodeDataChangeFailed):
+                    raise SerializationError("Expected reply_code_data to be type AccountReplyServerPacket.ReplyCodeDataChangeFailed for reply_code " + AccountReply(data._reply_code).name + ".")
+                AccountReplyServerPacket.ReplyCodeDataChangeFailed.serialize(writer, data._reply_code_data)
+            elif data._reply_code == AccountReply.Changed:
+                if not isinstance(data._reply_code_data, AccountReplyServerPacket.ReplyCodeDataChanged):
+                    raise SerializationError("Expected reply_code_data to be type AccountReplyServerPacket.ReplyCodeDataChanged for reply_code " + AccountReply(data._reply_code).name + ".")
+                AccountReplyServerPacket.ReplyCodeDataChanged.serialize(writer, data._reply_code_data)
+            elif data._reply_code == AccountReply.RequestDenied:
+                if not isinstance(data._reply_code_data, AccountReplyServerPacket.ReplyCodeDataRequestDenied):
+                    raise SerializationError("Expected reply_code_data to be type AccountReplyServerPacket.ReplyCodeDataRequestDenied for reply_code " + AccountReply(data._reply_code).name + ".")
+                AccountReplyServerPacket.ReplyCodeDataRequestDenied.serialize(writer, data._reply_code_data)
+            elif data._reply_code == 8:
+                if data._reply_code_data is not None:
+                    raise SerializationError("Expected reply_code_data to be None for reply_code " + AccountReply(data._reply_code).name + ".")
+            elif data._reply_code == 9:
+                if data._reply_code_data is not None:
+                    raise SerializationError("Expected reply_code_data to be None for reply_code " + AccountReply(data._reply_code).name + ".")
+            else:
+                if not isinstance(data._reply_code_data, AccountReplyServerPacket.ReplyCodeDataDefault):
+                    raise SerializationError("Expected reply_code_data to be type AccountReplyServerPacket.ReplyCodeDataDefault for reply_code " + AccountReply(data._reply_code).name + ".")
+                AccountReplyServerPacket.ReplyCodeDataDefault.serialize(writer, data._reply_code_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "AccountReplyServerPacket":
@@ -181,10 +188,9 @@ class AccountReplyServerPacket(Packet):
         return f"AccountReplyServerPacket(byte_size={repr(self._byte_size)}, reply_code={repr(self._reply_code)}, reply_code_data={repr(self._reply_code_data)})"
 
     ReplyCodeData = Union['AccountReplyServerPacket.ReplyCodeDataExists', 'AccountReplyServerPacket.ReplyCodeDataNotApproved', 'AccountReplyServerPacket.ReplyCodeDataCreated', 'AccountReplyServerPacket.ReplyCodeDataChangeFailed', 'AccountReplyServerPacket.ReplyCodeDataChanged', 'AccountReplyServerPacket.ReplyCodeDataRequestDenied', 'AccountReplyServerPacket.ReplyCodeDataDefault', None]
-    ReplyCodeData.__doc__ = \
-        """
-        Data associated with different values of the `reply_code` field.
-        """
+    """
+    Data associated with different values of the `reply_code` field.
+    """
 
     class ReplyCodeDataExists:
         """
@@ -212,7 +218,11 @@ class AccountReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (AccountReplyServerPacket.ReplyCodeDataExists): The data to serialize.
             """
-            writer.add_string("NO")
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                writer.add_string("NO")
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "AccountReplyServerPacket.ReplyCodeDataExists":
@@ -264,7 +274,11 @@ class AccountReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (AccountReplyServerPacket.ReplyCodeDataNotApproved): The data to serialize.
             """
-            writer.add_string("NO")
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                writer.add_string("NO")
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "AccountReplyServerPacket.ReplyCodeDataNotApproved":
@@ -316,7 +330,11 @@ class AccountReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (AccountReplyServerPacket.ReplyCodeDataCreated): The data to serialize.
             """
-            writer.add_string("GO")
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                writer.add_string("GO")
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "AccountReplyServerPacket.ReplyCodeDataCreated":
@@ -368,7 +386,11 @@ class AccountReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (AccountReplyServerPacket.ReplyCodeDataChangeFailed): The data to serialize.
             """
-            writer.add_string("NO")
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                writer.add_string("NO")
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "AccountReplyServerPacket.ReplyCodeDataChangeFailed":
@@ -420,7 +442,11 @@ class AccountReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (AccountReplyServerPacket.ReplyCodeDataChanged): The data to serialize.
             """
-            writer.add_string("NO")
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                writer.add_string("NO")
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "AccountReplyServerPacket.ReplyCodeDataChanged":
@@ -472,7 +498,11 @@ class AccountReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (AccountReplyServerPacket.ReplyCodeDataRequestDenied): The data to serialize.
             """
-            writer.add_string("NO")
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                writer.add_string("NO")
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "AccountReplyServerPacket.ReplyCodeDataRequestDenied":
@@ -542,10 +572,14 @@ class AccountReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (AccountReplyServerPacket.ReplyCodeDataDefault): The data to serialize.
             """
-            if data._sequence_start is None:
-                raise SerializationError("sequence_start must be provided.")
-            writer.add_char(data._sequence_start)
-            writer.add_string("OK")
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._sequence_start is None:
+                    raise SerializationError("sequence_start must be provided.")
+                writer.add_char(data._sequence_start)
+                writer.add_string("OK")
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "AccountReplyServerPacket.ReplyCodeDataDefault":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class AdminInteractAgreeServerPacket(Packet):
+    """
+    Nearby player appearing (admin un-hide)
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
 
@@ -78,9 +81,13 @@ class AdminInteractAgreeServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (AdminInteractAgreeServerPacket): 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) -> "AdminInteractAgreeServerPacket":

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

@@ -14,6 +14,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class AdminInteractListServerPacket(Packet):
+    """
+    Admin character inventory popup
+    """
     _byte_size: int = 0
     _name: str = None # type: ignore [assignment]
     _usage: int = None # type: ignore [assignment]
@@ -125,27 +128,33 @@ class AdminInteractListServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (AdminInteractListServerPacket): 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._usage is None:
-            raise SerializationError("usage must be provided.")
-        writer.add_int(data._usage)
-        writer.add_byte(0xFF)
-        if data._gold_bank is None:
-            raise SerializationError("gold_bank must be provided.")
-        writer.add_int(data._gold_bank)
-        writer.add_byte(0xFF)
-        if data._inventory is None:
-            raise SerializationError("inventory must be provided.")
-        for i in range(len(data._inventory)):
-            Item.serialize(writer, data._inventory[i])
-        writer.add_byte(0xFF)
-        if data._bank is None:
-            raise SerializationError("bank must be provided.")
-        for i in range(len(data._bank)):
-            ThreeItem.serialize(writer, data._bank[i])
+        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._usage is None:
+                raise SerializationError("usage must be provided.")
+            writer.add_int(data._usage)
+            writer.add_byte(0xFF)
+            if data._gold_bank is None:
+                raise SerializationError("gold_bank must be provided.")
+            writer.add_int(data._gold_bank)
+            writer.add_byte(0xFF)
+            if data._inventory is None:
+                raise SerializationError("inventory must be provided.")
+            for i in range(len(data._inventory)):
+                Item.serialize(writer, data._inventory[i])
+            writer.add_byte(0xFF)
+            if data._bank is None:
+                raise SerializationError("bank must be provided.")
+            for i in range(len(data._bank)):
+                ThreeItem.serialize(writer, data._bank[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "AdminInteractListServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class AdminInteractRemoveServerPacket(Packet):
+    """
+    Nearby player disappearing (admin hide)
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
 
@@ -78,9 +81,13 @@ class AdminInteractRemoveServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (AdminInteractRemoveServerPacket): 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) -> "AdminInteractRemoveServerPacket":

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class AdminInteractReplyServerPacket(Packet):
+    """
+    Incoming admin message
+    """
     _byte_size: int = 0
     _message_type: AdminMessageType = None # type: ignore [assignment]
     _message_type_data: 'AdminInteractReplyServerPacket.MessageTypeData' = None
@@ -84,18 +87,24 @@ class AdminInteractReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (AdminInteractReplyServerPacket): The data to serialize.
         """
-        if data._message_type is None:
-            raise SerializationError("message_type must be provided.")
-        writer.add_char(int(data._message_type))
-        writer.add_byte(0xFF)
-        if data._message_type == AdminMessageType.Message:
-            if not isinstance(data._message_type_data, AdminInteractReplyServerPacket.MessageTypeDataMessage):
-                raise SerializationError("Expected message_type_data to be type AdminInteractReplyServerPacket.MessageTypeDataMessage for message_type " + AdminMessageType(data._message_type).name + ".")
-            AdminInteractReplyServerPacket.MessageTypeDataMessage.serialize(writer, data._message_type_data)
-        elif data._message_type == AdminMessageType.Report:
-            if not isinstance(data._message_type_data, AdminInteractReplyServerPacket.MessageTypeDataReport):
-                raise SerializationError("Expected message_type_data to be type AdminInteractReplyServerPacket.MessageTypeDataReport for message_type " + AdminMessageType(data._message_type).name + ".")
-            AdminInteractReplyServerPacket.MessageTypeDataReport.serialize(writer, data._message_type_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._message_type is None:
+                raise SerializationError("message_type must be provided.")
+            writer.add_char(int(data._message_type))
+            writer.add_byte(0xFF)
+            if data._message_type == AdminMessageType.Message:
+                if not isinstance(data._message_type_data, AdminInteractReplyServerPacket.MessageTypeDataMessage):
+                    raise SerializationError("Expected message_type_data to be type AdminInteractReplyServerPacket.MessageTypeDataMessage for message_type " + AdminMessageType(data._message_type).name + ".")
+                AdminInteractReplyServerPacket.MessageTypeDataMessage.serialize(writer, data._message_type_data)
+            elif data._message_type == AdminMessageType.Report:
+                if not isinstance(data._message_type_data, AdminInteractReplyServerPacket.MessageTypeDataReport):
+                    raise SerializationError("Expected message_type_data to be type AdminInteractReplyServerPacket.MessageTypeDataReport for message_type " + AdminMessageType(data._message_type).name + ".")
+                AdminInteractReplyServerPacket.MessageTypeDataReport.serialize(writer, data._message_type_data)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "AdminInteractReplyServerPacket":
@@ -129,10 +138,9 @@ class AdminInteractReplyServerPacket(Packet):
         return f"AdminInteractReplyServerPacket(byte_size={repr(self._byte_size)}, message_type={repr(self._message_type)}, message_type_data={repr(self._message_type_data)})"
 
     MessageTypeData = Union['AdminInteractReplyServerPacket.MessageTypeDataMessage', 'AdminInteractReplyServerPacket.MessageTypeDataReport', None]
-    MessageTypeData.__doc__ = \
-        """
-        Data associated with different values of the `message_type` field.
-        """
+    """
+    Data associated with different values of the `message_type` field.
+    """
 
     class MessageTypeDataMessage:
         """
@@ -177,14 +185,18 @@ class AdminInteractReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (AdminInteractReplyServerPacket.MessageTypeDataMessage): 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)
-            writer.add_byte(0xFF)
+            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)
+                writer.add_byte(0xFF)
+                if data._message is None:
+                    raise SerializationError("message must be provided.")
+                writer.add_string(data._message)
+                writer.add_byte(0xFF)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "AdminInteractReplyServerPacket.MessageTypeDataMessage":
@@ -265,18 +277,22 @@ class AdminInteractReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (AdminInteractReplyServerPacket.MessageTypeDataReport): 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)
-            writer.add_byte(0xFF)
-            if data._reportee_name is None:
-                raise SerializationError("reportee_name must be provided.")
-            writer.add_string(data._reportee_name)
-            writer.add_byte(0xFF)
+            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)
+                writer.add_byte(0xFF)
+                if data._message is None:
+                    raise SerializationError("message must be provided.")
+                writer.add_string(data._message)
+                writer.add_byte(0xFF)
+                if data._reportee_name is None:
+                    raise SerializationError("reportee_name must be provided.")
+                writer.add_string(data._reportee_name)
+                writer.add_byte(0xFF)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "AdminInteractReplyServerPacket.MessageTypeDataReport":

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

@@ -14,6 +14,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class AdminInteractTellServerPacket(Packet):
+    """
+    Admin character info lookup
+    """
     _byte_size: int = 0
     _name: str = None # type: ignore [assignment]
     _usage: int = None # type: ignore [assignment]
@@ -168,33 +171,39 @@ class AdminInteractTellServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (AdminInteractTellServerPacket): 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._usage is None:
-            raise SerializationError("usage must be provided.")
-        writer.add_int(data._usage)
-        writer.add_byte(0xFF)
-        writer.add_byte(0xFF)
-        if data._exp is None:
-            raise SerializationError("exp must be provided.")
-        writer.add_int(data._exp)
-        if data._level is None:
-            raise SerializationError("level must be provided.")
-        writer.add_char(data._level)
-        if data._map_id is None:
-            raise SerializationError("map_id must be provided.")
-        writer.add_short(data._map_id)
-        if data._map_coords is None:
-            raise SerializationError("map_coords must be provided.")
-        BigCoords.serialize(writer, data._map_coords)
-        if data._stats is None:
-            raise SerializationError("stats must be provided.")
-        CharacterStatsInfoLookup.serialize(writer, data._stats)
-        if data._weight is None:
-            raise SerializationError("weight must be provided.")
-        Weight.serialize(writer, data._weight)
+        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._usage is None:
+                raise SerializationError("usage must be provided.")
+            writer.add_int(data._usage)
+            writer.add_byte(0xFF)
+            writer.add_byte(0xFF)
+            if data._exp is None:
+                raise SerializationError("exp must be provided.")
+            writer.add_int(data._exp)
+            if data._level is None:
+                raise SerializationError("level must be provided.")
+            writer.add_char(data._level)
+            if data._map_id is None:
+                raise SerializationError("map_id must be provided.")
+            writer.add_short(data._map_id)
+            if data._map_coords is None:
+                raise SerializationError("map_coords must be provided.")
+            BigCoords.serialize(writer, data._map_coords)
+            if data._stats is None:
+                raise SerializationError("stats must be provided.")
+            CharacterStatsInfoLookup.serialize(writer, data._stats)
+            if data._weight is None:
+                raise SerializationError("weight must be provided.")
+            Weight.serialize(writer, data._weight)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "AdminInteractTellServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ArenaAcceptServerPacket(Packet):
+    """
+    Arena win message
+    """
     _byte_size: int = 0
     _winner_name: str = None # type: ignore [assignment]
     _kills_count: int = None # type: ignore [assignment]
@@ -105,21 +108,27 @@ class ArenaAcceptServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ArenaAcceptServerPacket): The data to serialize.
         """
-        if data._winner_name is None:
-            raise SerializationError("winner_name must be provided.")
-        writer.add_string(data._winner_name)
-        writer.add_byte(0xFF)
-        if data._kills_count is None:
-            raise SerializationError("kills_count must be provided.")
-        writer.add_int(data._kills_count)
-        writer.add_byte(0xFF)
-        if data._killer_name is None:
-            raise SerializationError("killer_name must be provided.")
-        writer.add_string(data._killer_name)
-        writer.add_byte(0xFF)
-        if data._victim_name is None:
-            raise SerializationError("victim_name must be provided.")
-        writer.add_string(data._victim_name)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._winner_name is None:
+                raise SerializationError("winner_name must be provided.")
+            writer.add_string(data._winner_name)
+            writer.add_byte(0xFF)
+            if data._kills_count is None:
+                raise SerializationError("kills_count must be provided.")
+            writer.add_int(data._kills_count)
+            writer.add_byte(0xFF)
+            if data._killer_name is None:
+                raise SerializationError("killer_name must be provided.")
+            writer.add_string(data._killer_name)
+            writer.add_byte(0xFF)
+            if data._victim_name is None:
+                raise SerializationError("victim_name must be provided.")
+            writer.add_string(data._victim_name)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ArenaAcceptServerPacket":