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

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

@@ -104,32 +104,36 @@ class WelcomeAgreeClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (WelcomeAgreeClientPacket): The data to serialize.
         """
-        if data._file_type is None:
-            raise SerializationError("file_type must be provided.")
-        writer.add_char(int(data._file_type))
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_short(data._session_id)
-        if data._file_type == FileType.Emf:
-            if not isinstance(data._file_type_data, WelcomeAgreeClientPacket.FileTypeDataEmf):
-                raise SerializationError("Expected file_type_data to be type WelcomeAgreeClientPacket.FileTypeDataEmf for file_type " + FileType(data._file_type).name + ".")
-            WelcomeAgreeClientPacket.FileTypeDataEmf.serialize(writer, data._file_type_data)
-        elif data._file_type == FileType.Eif:
-            if not isinstance(data._file_type_data, WelcomeAgreeClientPacket.FileTypeDataEif):
-                raise SerializationError("Expected file_type_data to be type WelcomeAgreeClientPacket.FileTypeDataEif for file_type " + FileType(data._file_type).name + ".")
-            WelcomeAgreeClientPacket.FileTypeDataEif.serialize(writer, data._file_type_data)
-        elif data._file_type == FileType.Enf:
-            if not isinstance(data._file_type_data, WelcomeAgreeClientPacket.FileTypeDataEnf):
-                raise SerializationError("Expected file_type_data to be type WelcomeAgreeClientPacket.FileTypeDataEnf for file_type " + FileType(data._file_type).name + ".")
-            WelcomeAgreeClientPacket.FileTypeDataEnf.serialize(writer, data._file_type_data)
-        elif data._file_type == FileType.Esf:
-            if not isinstance(data._file_type_data, WelcomeAgreeClientPacket.FileTypeDataEsf):
-                raise SerializationError("Expected file_type_data to be type WelcomeAgreeClientPacket.FileTypeDataEsf for file_type " + FileType(data._file_type).name + ".")
-            WelcomeAgreeClientPacket.FileTypeDataEsf.serialize(writer, data._file_type_data)
-        elif data._file_type == FileType.Ecf:
-            if not isinstance(data._file_type_data, WelcomeAgreeClientPacket.FileTypeDataEcf):
-                raise SerializationError("Expected file_type_data to be type WelcomeAgreeClientPacket.FileTypeDataEcf for file_type " + FileType(data._file_type).name + ".")
-            WelcomeAgreeClientPacket.FileTypeDataEcf.serialize(writer, data._file_type_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._file_type is None:
+                raise SerializationError("file_type must be provided.")
+            writer.add_char(int(data._file_type))
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_short(data._session_id)
+            if data._file_type == FileType.Emf:
+                if not isinstance(data._file_type_data, WelcomeAgreeClientPacket.FileTypeDataEmf):
+                    raise SerializationError("Expected file_type_data to be type WelcomeAgreeClientPacket.FileTypeDataEmf for file_type " + FileType(data._file_type).name + ".")
+                WelcomeAgreeClientPacket.FileTypeDataEmf.serialize(writer, data._file_type_data)
+            elif data._file_type == FileType.Eif:
+                if not isinstance(data._file_type_data, WelcomeAgreeClientPacket.FileTypeDataEif):
+                    raise SerializationError("Expected file_type_data to be type WelcomeAgreeClientPacket.FileTypeDataEif for file_type " + FileType(data._file_type).name + ".")
+                WelcomeAgreeClientPacket.FileTypeDataEif.serialize(writer, data._file_type_data)
+            elif data._file_type == FileType.Enf:
+                if not isinstance(data._file_type_data, WelcomeAgreeClientPacket.FileTypeDataEnf):
+                    raise SerializationError("Expected file_type_data to be type WelcomeAgreeClientPacket.FileTypeDataEnf for file_type " + FileType(data._file_type).name + ".")
+                WelcomeAgreeClientPacket.FileTypeDataEnf.serialize(writer, data._file_type_data)
+            elif data._file_type == FileType.Esf:
+                if not isinstance(data._file_type_data, WelcomeAgreeClientPacket.FileTypeDataEsf):
+                    raise SerializationError("Expected file_type_data to be type WelcomeAgreeClientPacket.FileTypeDataEsf for file_type " + FileType(data._file_type).name + ".")
+                WelcomeAgreeClientPacket.FileTypeDataEsf.serialize(writer, data._file_type_data)
+            elif data._file_type == FileType.Ecf:
+                if not isinstance(data._file_type_data, WelcomeAgreeClientPacket.FileTypeDataEcf):
+                    raise SerializationError("Expected file_type_data to be type WelcomeAgreeClientPacket.FileTypeDataEcf for file_type " + FileType(data._file_type).name + ".")
+                WelcomeAgreeClientPacket.FileTypeDataEcf.serialize(writer, data._file_type_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "WelcomeAgreeClientPacket":
@@ -167,10 +171,9 @@ class WelcomeAgreeClientPacket(Packet):
         return f"WelcomeAgreeClientPacket(byte_size={repr(self._byte_size)}, file_type={repr(self._file_type)}, session_id={repr(self._session_id)}, file_type_data={repr(self._file_type_data)})"
 
     FileTypeData = Union['WelcomeAgreeClientPacket.FileTypeDataEmf', 'WelcomeAgreeClientPacket.FileTypeDataEif', 'WelcomeAgreeClientPacket.FileTypeDataEnf', 'WelcomeAgreeClientPacket.FileTypeDataEsf', 'WelcomeAgreeClientPacket.FileTypeDataEcf', None]
-    FileTypeData.__doc__ = \
-        """
-        Data associated with different values of the `file_type` field.
-        """
+    """
+    Data associated with different values of the `file_type` field.
+    """
 
     class FileTypeDataEmf:
         """
@@ -214,9 +217,13 @@ class WelcomeAgreeClientPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (WelcomeAgreeClientPacket.FileTypeDataEmf): The data to serialize.
             """
-            if data._file_id is None:
-                raise SerializationError("file_id must be provided.")
-            writer.add_short(data._file_id)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._file_id is None:
+                    raise SerializationError("file_id must be provided.")
+                writer.add_short(data._file_id)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "WelcomeAgreeClientPacket.FileTypeDataEmf":
@@ -284,9 +291,13 @@ class WelcomeAgreeClientPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (WelcomeAgreeClientPacket.FileTypeDataEif): The data to serialize.
             """
-            if data._file_id is None:
-                raise SerializationError("file_id must be provided.")
-            writer.add_char(data._file_id)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._file_id is None:
+                    raise SerializationError("file_id must be provided.")
+                writer.add_char(data._file_id)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "WelcomeAgreeClientPacket.FileTypeDataEif":
@@ -354,9 +365,13 @@ class WelcomeAgreeClientPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (WelcomeAgreeClientPacket.FileTypeDataEnf): The data to serialize.
             """
-            if data._file_id is None:
-                raise SerializationError("file_id must be provided.")
-            writer.add_char(data._file_id)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._file_id is None:
+                    raise SerializationError("file_id must be provided.")
+                writer.add_char(data._file_id)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "WelcomeAgreeClientPacket.FileTypeDataEnf":
@@ -424,9 +439,13 @@ class WelcomeAgreeClientPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (WelcomeAgreeClientPacket.FileTypeDataEsf): The data to serialize.
             """
-            if data._file_id is None:
-                raise SerializationError("file_id must be provided.")
-            writer.add_char(data._file_id)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._file_id is None:
+                    raise SerializationError("file_id must be provided.")
+                writer.add_char(data._file_id)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "WelcomeAgreeClientPacket.FileTypeDataEsf":
@@ -494,9 +513,13 @@ class WelcomeAgreeClientPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (WelcomeAgreeClientPacket.FileTypeDataEcf): The data to serialize.
             """
-            if data._file_id is None:
-                raise SerializationError("file_id must be provided.")
-            writer.add_char(data._file_id)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._file_id is None:
+                    raise SerializationError("file_id must be provided.")
+                writer.add_char(data._file_id)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "WelcomeAgreeClientPacket.FileTypeDataEcf":

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

@@ -98,12 +98,16 @@ class WelcomeMsgClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (WelcomeMsgClientPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_three(data._session_id)
-        if data._character_id is None:
-            raise SerializationError("character_id must be provided.")
-        writer.add_int(data._character_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_three(data._session_id)
+            if data._character_id is None:
+                raise SerializationError("character_id must be provided.")
+            writer.add_int(data._character_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "WelcomeMsgClientPacket":

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

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

eolib/protocol/_generated/net/item.py

@@ -66,12 +66,16 @@ class Item:
             writer (EoWriter): The writer that the data will be serialized to.
             data (Item): The data to serialize.
         """
-        if data._id is None:
-            raise SerializationError("id must be provided.")
-        writer.add_short(data._id)
-        if data._amount is None:
-            raise SerializationError("amount must be provided.")
-        writer.add_int(data._amount)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._id is None:
+                raise SerializationError("id must be provided.")
+            writer.add_short(data._id)
+            if data._amount is None:
+                raise SerializationError("amount must be provided.")
+            writer.add_int(data._amount)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "Item":

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

@@ -93,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":
@@ -184,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:
         """
@@ -215,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":
@@ -267,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":
@@ -319,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":
@@ -371,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":
@@ -423,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":
@@ -475,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":
@@ -545,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

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

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

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