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

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

@@ -95,49 +95,55 @@ class CharacterReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CharacterReplyServerPacket): 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 " + CharacterReply(data._reply_code).name + ".")
-        elif data._reply_code == CharacterReply.Exists:
-            if not isinstance(data._reply_code_data, CharacterReplyServerPacket.ReplyCodeDataExists):
-                raise SerializationError("Expected reply_code_data to be type CharacterReplyServerPacket.ReplyCodeDataExists for reply_code " + CharacterReply(data._reply_code).name + ".")
-            CharacterReplyServerPacket.ReplyCodeDataExists.serialize(writer, data._reply_code_data)
-        elif data._reply_code == CharacterReply.Full:
-            if not isinstance(data._reply_code_data, CharacterReplyServerPacket.ReplyCodeDataFull):
-                raise SerializationError("Expected reply_code_data to be type CharacterReplyServerPacket.ReplyCodeDataFull for reply_code " + CharacterReply(data._reply_code).name + ".")
-            CharacterReplyServerPacket.ReplyCodeDataFull.serialize(writer, data._reply_code_data)
-        elif data._reply_code == CharacterReply.Full3:
-            if not isinstance(data._reply_code_data, CharacterReplyServerPacket.ReplyCodeDataFull3):
-                raise SerializationError("Expected reply_code_data to be type CharacterReplyServerPacket.ReplyCodeDataFull3 for reply_code " + CharacterReply(data._reply_code).name + ".")
-            CharacterReplyServerPacket.ReplyCodeDataFull3.serialize(writer, data._reply_code_data)
-        elif data._reply_code == CharacterReply.NotApproved:
-            if not isinstance(data._reply_code_data, CharacterReplyServerPacket.ReplyCodeDataNotApproved):
-                raise SerializationError("Expected reply_code_data to be type CharacterReplyServerPacket.ReplyCodeDataNotApproved for reply_code " + CharacterReply(data._reply_code).name + ".")
-            CharacterReplyServerPacket.ReplyCodeDataNotApproved.serialize(writer, data._reply_code_data)
-        elif data._reply_code == CharacterReply.Ok:
-            if not isinstance(data._reply_code_data, CharacterReplyServerPacket.ReplyCodeDataOk):
-                raise SerializationError("Expected reply_code_data to be type CharacterReplyServerPacket.ReplyCodeDataOk for reply_code " + CharacterReply(data._reply_code).name + ".")
-            CharacterReplyServerPacket.ReplyCodeDataOk.serialize(writer, data._reply_code_data)
-        elif data._reply_code == CharacterReply.Deleted:
-            if not isinstance(data._reply_code_data, CharacterReplyServerPacket.ReplyCodeDataDeleted):
-                raise SerializationError("Expected reply_code_data to be type CharacterReplyServerPacket.ReplyCodeDataDeleted for reply_code " + CharacterReply(data._reply_code).name + ".")
-            CharacterReplyServerPacket.ReplyCodeDataDeleted.serialize(writer, data._reply_code_data)
-        elif data._reply_code == 7:
-            if data._reply_code_data is not None:
-                raise SerializationError("Expected reply_code_data to be None for reply_code " + CharacterReply(data._reply_code).name + ".")
-        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 " + CharacterReply(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 " + CharacterReply(data._reply_code).name + ".")
-        else:
-            if not isinstance(data._reply_code_data, CharacterReplyServerPacket.ReplyCodeDataDefault):
-                raise SerializationError("Expected reply_code_data to be type CharacterReplyServerPacket.ReplyCodeDataDefault for reply_code " + CharacterReply(data._reply_code).name + ".")
-            CharacterReplyServerPacket.ReplyCodeDataDefault.serialize(writer, data._reply_code_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            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 " + CharacterReply(data._reply_code).name + ".")
+            elif data._reply_code == CharacterReply.Exists:
+                if not isinstance(data._reply_code_data, CharacterReplyServerPacket.ReplyCodeDataExists):
+                    raise SerializationError("Expected reply_code_data to be type CharacterReplyServerPacket.ReplyCodeDataExists for reply_code " + CharacterReply(data._reply_code).name + ".")
+                CharacterReplyServerPacket.ReplyCodeDataExists.serialize(writer, data._reply_code_data)
+            elif data._reply_code == CharacterReply.Full:
+                if not isinstance(data._reply_code_data, CharacterReplyServerPacket.ReplyCodeDataFull):
+                    raise SerializationError("Expected reply_code_data to be type CharacterReplyServerPacket.ReplyCodeDataFull for reply_code " + CharacterReply(data._reply_code).name + ".")
+                CharacterReplyServerPacket.ReplyCodeDataFull.serialize(writer, data._reply_code_data)
+            elif data._reply_code == CharacterReply.Full3:
+                if not isinstance(data._reply_code_data, CharacterReplyServerPacket.ReplyCodeDataFull3):
+                    raise SerializationError("Expected reply_code_data to be type CharacterReplyServerPacket.ReplyCodeDataFull3 for reply_code " + CharacterReply(data._reply_code).name + ".")
+                CharacterReplyServerPacket.ReplyCodeDataFull3.serialize(writer, data._reply_code_data)
+            elif data._reply_code == CharacterReply.NotApproved:
+                if not isinstance(data._reply_code_data, CharacterReplyServerPacket.ReplyCodeDataNotApproved):
+                    raise SerializationError("Expected reply_code_data to be type CharacterReplyServerPacket.ReplyCodeDataNotApproved for reply_code " + CharacterReply(data._reply_code).name + ".")
+                CharacterReplyServerPacket.ReplyCodeDataNotApproved.serialize(writer, data._reply_code_data)
+            elif data._reply_code == CharacterReply.Ok:
+                if not isinstance(data._reply_code_data, CharacterReplyServerPacket.ReplyCodeDataOk):
+                    raise SerializationError("Expected reply_code_data to be type CharacterReplyServerPacket.ReplyCodeDataOk for reply_code " + CharacterReply(data._reply_code).name + ".")
+                CharacterReplyServerPacket.ReplyCodeDataOk.serialize(writer, data._reply_code_data)
+            elif data._reply_code == CharacterReply.Deleted:
+                if not isinstance(data._reply_code_data, CharacterReplyServerPacket.ReplyCodeDataDeleted):
+                    raise SerializationError("Expected reply_code_data to be type CharacterReplyServerPacket.ReplyCodeDataDeleted for reply_code " + CharacterReply(data._reply_code).name + ".")
+                CharacterReplyServerPacket.ReplyCodeDataDeleted.serialize(writer, data._reply_code_data)
+            elif data._reply_code == 7:
+                if data._reply_code_data is not None:
+                    raise SerializationError("Expected reply_code_data to be None for reply_code " + CharacterReply(data._reply_code).name + ".")
+            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 " + CharacterReply(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 " + CharacterReply(data._reply_code).name + ".")
+            else:
+                if not isinstance(data._reply_code_data, CharacterReplyServerPacket.ReplyCodeDataDefault):
+                    raise SerializationError("Expected reply_code_data to be type CharacterReplyServerPacket.ReplyCodeDataDefault for reply_code " + CharacterReply(data._reply_code).name + ".")
+                CharacterReplyServerPacket.ReplyCodeDataDefault.serialize(writer, data._reply_code_data)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CharacterReplyServerPacket":
@@ -188,10 +194,9 @@ class CharacterReplyServerPacket(Packet):
         return f"CharacterReplyServerPacket(byte_size={repr(self._byte_size)}, reply_code={repr(self._reply_code)}, reply_code_data={repr(self._reply_code_data)})"
 
     ReplyCodeData = Union['CharacterReplyServerPacket.ReplyCodeDataExists', 'CharacterReplyServerPacket.ReplyCodeDataFull', 'CharacterReplyServerPacket.ReplyCodeDataFull3', 'CharacterReplyServerPacket.ReplyCodeDataNotApproved', 'CharacterReplyServerPacket.ReplyCodeDataOk', 'CharacterReplyServerPacket.ReplyCodeDataDeleted', 'CharacterReplyServerPacket.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:
         """
@@ -219,7 +224,11 @@ class CharacterReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (CharacterReplyServerPacket.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) -> "CharacterReplyServerPacket.ReplyCodeDataExists":
@@ -271,7 +280,11 @@ class CharacterReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (CharacterReplyServerPacket.ReplyCodeDataFull): 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) -> "CharacterReplyServerPacket.ReplyCodeDataFull":
@@ -323,7 +336,11 @@ class CharacterReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (CharacterReplyServerPacket.ReplyCodeDataFull3): 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) -> "CharacterReplyServerPacket.ReplyCodeDataFull3":
@@ -375,7 +392,11 @@ class CharacterReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (CharacterReplyServerPacket.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) -> "CharacterReplyServerPacket.ReplyCodeDataNotApproved":
@@ -445,19 +466,22 @@ class CharacterReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (CharacterReplyServerPacket.ReplyCodeDataOk): The data to serialize.
             """
-            if data._characters_count is None:
-                raise SerializationError("characters_count must be provided.")
-            writer.add_char(data._characters_count)
-            writer.add_char(0)
-            writer.add_byte(0xFF)
-            if data._characters is None:
-                raise SerializationError("characters must be provided.")
-            if len(data._characters) > 252:
-                raise SerializationError(f"Expected length of characters to be 252 or less, got {len(data._characters)}.")
-            for i in range(data._characters_count):
-                if i > 0:
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._characters_count is None:
+                    raise SerializationError("characters_count must be provided.")
+                writer.add_char(data._characters_count)
+                writer.add_char(0)
+                writer.add_byte(0xFF)
+                if data._characters is None:
+                    raise SerializationError("characters must be provided.")
+                if len(data._characters) > 252:
+                    raise SerializationError(f"Expected length of characters to be 252 or less, got {len(data._characters)}.")
+                for i in range(data._characters_count):
+                    CharacterSelectionListEntry.serialize(writer, data._characters[i])
                     writer.add_byte(0xFF)
-                CharacterSelectionListEntry.serialize(writer, data._characters[i])
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "CharacterReplyServerPacket.ReplyCodeDataOk":
@@ -480,8 +504,7 @@ class CharacterReplyServerPacket(Packet):
                 data._characters = []
                 for i in range(data._characters_count):
                     data._characters.append(CharacterSelectionListEntry.deserialize(reader))
-                    if i + 1 < data._characters_count:
-                        reader.next_chunk()
+                    reader.next_chunk()
                 data._byte_size = reader.position - reader_start_position
                 return data
             finally:
@@ -534,18 +557,21 @@ class CharacterReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (CharacterReplyServerPacket.ReplyCodeDataDeleted): The data to serialize.
             """
-            if data._characters_count is None:
-                raise SerializationError("characters_count must be provided.")
-            writer.add_char(data._characters_count)
-            writer.add_byte(0xFF)
-            if data._characters is None:
-                raise SerializationError("characters must be provided.")
-            if len(data._characters) > 252:
-                raise SerializationError(f"Expected length of characters to be 252 or less, got {len(data._characters)}.")
-            for i in range(data._characters_count):
-                if i > 0:
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._characters_count is None:
+                    raise SerializationError("characters_count must be provided.")
+                writer.add_char(data._characters_count)
+                writer.add_byte(0xFF)
+                if data._characters is None:
+                    raise SerializationError("characters must be provided.")
+                if len(data._characters) > 252:
+                    raise SerializationError(f"Expected length of characters to be 252 or less, got {len(data._characters)}.")
+                for i in range(data._characters_count):
+                    CharacterSelectionListEntry.serialize(writer, data._characters[i])
                     writer.add_byte(0xFF)
-                CharacterSelectionListEntry.serialize(writer, data._characters[i])
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "CharacterReplyServerPacket.ReplyCodeDataDeleted":
@@ -567,8 +593,7 @@ class CharacterReplyServerPacket(Packet):
                 data._characters = []
                 for i in range(data._characters_count):
                     data._characters.append(CharacterSelectionListEntry.deserialize(reader))
-                    if i + 1 < data._characters_count:
-                        reader.next_chunk()
+                    reader.next_chunk()
                 data._byte_size = reader.position - reader_start_position
                 return data
             finally:
@@ -605,7 +630,11 @@ class CharacterReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (CharacterReplyServerPacket.ReplyCodeDataDefault): The data to serialize.
             """
-            writer.add_string("OK")
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                writer.add_string("OK")
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "CharacterReplyServerPacket.ReplyCodeDataDefault":

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

@@ -117,21 +117,25 @@ class CharacterSecondaryStats:
             writer (EoWriter): The writer that the data will be serialized to.
             data (CharacterSecondaryStats): The data to serialize.
         """
-        if data._min_damage is None:
-            raise SerializationError("min_damage must be provided.")
-        writer.add_short(data._min_damage)
-        if data._max_damage is None:
-            raise SerializationError("max_damage must be provided.")
-        writer.add_short(data._max_damage)
-        if data._accuracy is None:
-            raise SerializationError("accuracy must be provided.")
-        writer.add_short(data._accuracy)
-        if data._evade is None:
-            raise SerializationError("evade must be provided.")
-        writer.add_short(data._evade)
-        if data._armor is None:
-            raise SerializationError("armor must be provided.")
-        writer.add_short(data._armor)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._min_damage is None:
+                raise SerializationError("min_damage must be provided.")
+            writer.add_short(data._min_damage)
+            if data._max_damage is None:
+                raise SerializationError("max_damage must be provided.")
+            writer.add_short(data._max_damage)
+            if data._accuracy is None:
+                raise SerializationError("accuracy must be provided.")
+            writer.add_short(data._accuracy)
+            if data._evade is None:
+                raise SerializationError("evade must be provided.")
+            writer.add_short(data._evade)
+            if data._armor is None:
+                raise SerializationError("armor must be provided.")
+            writer.add_short(data._armor)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CharacterSecondaryStats":

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

@@ -118,21 +118,25 @@ class CharacterSecondaryStatsInfoLookup:
             writer (EoWriter): The writer that the data will be serialized to.
             data (CharacterSecondaryStatsInfoLookup): The data to serialize.
         """
-        if data._max_damage is None:
-            raise SerializationError("max_damage must be provided.")
-        writer.add_short(data._max_damage)
-        if data._min_damage is None:
-            raise SerializationError("min_damage must be provided.")
-        writer.add_short(data._min_damage)
-        if data._accuracy is None:
-            raise SerializationError("accuracy must be provided.")
-        writer.add_short(data._accuracy)
-        if data._evade is None:
-            raise SerializationError("evade must be provided.")
-        writer.add_short(data._evade)
-        if data._armor is None:
-            raise SerializationError("armor must be provided.")
-        writer.add_short(data._armor)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._max_damage is None:
+                raise SerializationError("max_damage must be provided.")
+            writer.add_short(data._max_damage)
+            if data._min_damage is None:
+                raise SerializationError("min_damage must be provided.")
+            writer.add_short(data._min_damage)
+            if data._accuracy is None:
+                raise SerializationError("accuracy must be provided.")
+            writer.add_short(data._accuracy)
+            if data._evade is None:
+                raise SerializationError("evade must be provided.")
+            writer.add_short(data._evade)
+            if data._armor is None:
+                raise SerializationError("armor must be provided.")
+            writer.add_short(data._armor)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CharacterSecondaryStatsInfoLookup":

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

@@ -156,34 +156,40 @@ class CharacterSelectionListEntry:
             writer (EoWriter): The writer that the data will be serialized to.
             data (CharacterSelectionListEntry): 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._id is None:
-            raise SerializationError("id must be provided.")
-        writer.add_int(data._id)
-        if data._level is None:
-            raise SerializationError("level must be provided.")
-        writer.add_char(data._level)
-        if data._gender is None:
-            raise SerializationError("gender must be provided.")
-        writer.add_char(int(data._gender))
-        if data._hair_style is None:
-            raise SerializationError("hair_style must be provided.")
-        writer.add_char(data._hair_style)
-        if data._hair_color is None:
-            raise SerializationError("hair_color must be provided.")
-        writer.add_char(data._hair_color)
-        if data._skin is None:
-            raise SerializationError("skin must be provided.")
-        writer.add_char(data._skin)
-        if data._admin is None:
-            raise SerializationError("admin must be provided.")
-        writer.add_char(int(data._admin))
-        if data._equipment is None:
-            raise SerializationError("equipment must be provided.")
-        EquipmentCharacterSelect.serialize(writer, data._equipment)
+        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._id is None:
+                raise SerializationError("id must be provided.")
+            writer.add_int(data._id)
+            if data._level is None:
+                raise SerializationError("level must be provided.")
+            writer.add_char(data._level)
+            if data._gender is None:
+                raise SerializationError("gender must be provided.")
+            writer.add_char(int(data._gender))
+            if data._hair_style is None:
+                raise SerializationError("hair_style must be provided.")
+            writer.add_char(data._hair_style)
+            if data._hair_color is None:
+                raise SerializationError("hair_color must be provided.")
+            writer.add_char(data._hair_color)
+            if data._skin is None:
+                raise SerializationError("skin must be provided.")
+            writer.add_char(data._skin)
+            if data._admin is None:
+                raise SerializationError("admin must be provided.")
+            writer.add_char(int(data._admin))
+            if data._equipment is None:
+                raise SerializationError("equipment must be provided.")
+            EquipmentCharacterSelect.serialize(writer, data._equipment)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CharacterSelectionListEntry":

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

@@ -87,18 +87,22 @@ class CharacterStatsEquipmentChange:
             writer (EoWriter): The writer that the data will be serialized to.
             data (CharacterStatsEquipmentChange): The data to serialize.
         """
-        if data._max_hp is None:
-            raise SerializationError("max_hp must be provided.")
-        writer.add_short(data._max_hp)
-        if data._max_tp is None:
-            raise SerializationError("max_tp must be provided.")
-        writer.add_short(data._max_tp)
-        if data._base_stats is None:
-            raise SerializationError("base_stats must be provided.")
-        CharacterBaseStats.serialize(writer, data._base_stats)
-        if data._secondary_stats is None:
-            raise SerializationError("secondary_stats must be provided.")
-        CharacterSecondaryStats.serialize(writer, data._secondary_stats)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._max_hp is None:
+                raise SerializationError("max_hp must be provided.")
+            writer.add_short(data._max_hp)
+            if data._max_tp is None:
+                raise SerializationError("max_tp must be provided.")
+            writer.add_short(data._max_tp)
+            if data._base_stats is None:
+                raise SerializationError("base_stats must be provided.")
+            CharacterBaseStats.serialize(writer, data._base_stats)
+            if data._secondary_stats is None:
+                raise SerializationError("secondary_stats must be provided.")
+            CharacterSecondaryStats.serialize(writer, data._secondary_stats)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CharacterStatsEquipmentChange":

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

@@ -131,27 +131,31 @@ class CharacterStatsInfoLookup:
             writer (EoWriter): The writer that the data will be serialized to.
             data (CharacterStatsInfoLookup): The data to serialize.
         """
-        if data._hp is None:
-            raise SerializationError("hp must be provided.")
-        writer.add_short(data._hp)
-        if data._max_hp is None:
-            raise SerializationError("max_hp must be provided.")
-        writer.add_short(data._max_hp)
-        if data._tp is None:
-            raise SerializationError("tp must be provided.")
-        writer.add_short(data._tp)
-        if data._max_tp is None:
-            raise SerializationError("max_tp must be provided.")
-        writer.add_short(data._max_tp)
-        if data._base_stats is None:
-            raise SerializationError("base_stats must be provided.")
-        CharacterBaseStats.serialize(writer, data._base_stats)
-        if data._secondary_stats is None:
-            raise SerializationError("secondary_stats must be provided.")
-        CharacterSecondaryStats.serialize(writer, data._secondary_stats)
-        if data._elemental_stats is None:
-            raise SerializationError("elemental_stats must be provided.")
-        CharacterElementalStats.serialize(writer, data._elemental_stats)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._hp is None:
+                raise SerializationError("hp must be provided.")
+            writer.add_short(data._hp)
+            if data._max_hp is None:
+                raise SerializationError("max_hp must be provided.")
+            writer.add_short(data._max_hp)
+            if data._tp is None:
+                raise SerializationError("tp must be provided.")
+            writer.add_short(data._tp)
+            if data._max_tp is None:
+                raise SerializationError("max_tp must be provided.")
+            writer.add_short(data._max_tp)
+            if data._base_stats is None:
+                raise SerializationError("base_stats must be provided.")
+            CharacterBaseStats.serialize(writer, data._base_stats)
+            if data._secondary_stats is None:
+                raise SerializationError("secondary_stats must be provided.")
+            CharacterSecondaryStats.serialize(writer, data._secondary_stats)
+            if data._elemental_stats is None:
+                raise SerializationError("elemental_stats must be provided.")
+            CharacterElementalStats.serialize(writer, data._elemental_stats)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CharacterStatsInfoLookup":

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

@@ -172,33 +172,37 @@ class CharacterStatsReset:
             writer (EoWriter): The writer that the data will be serialized to.
             data (CharacterStatsReset): The data to serialize.
         """
-        if data._stat_points is None:
-            raise SerializationError("stat_points must be provided.")
-        writer.add_short(data._stat_points)
-        if data._skill_points is None:
-            raise SerializationError("skill_points must be provided.")
-        writer.add_short(data._skill_points)
-        if data._hp is None:
-            raise SerializationError("hp must be provided.")
-        writer.add_short(data._hp)
-        if data._max_hp is None:
-            raise SerializationError("max_hp must be provided.")
-        writer.add_short(data._max_hp)
-        if data._tp is None:
-            raise SerializationError("tp must be provided.")
-        writer.add_short(data._tp)
-        if data._max_tp is None:
-            raise SerializationError("max_tp must be provided.")
-        writer.add_short(data._max_tp)
-        if data._max_sp is None:
-            raise SerializationError("max_sp must be provided.")
-        writer.add_short(data._max_sp)
-        if data._base is None:
-            raise SerializationError("base must be provided.")
-        CharacterBaseStats.serialize(writer, data._base)
-        if data._secondary is None:
-            raise SerializationError("secondary must be provided.")
-        CharacterSecondaryStats.serialize(writer, data._secondary)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._stat_points is None:
+                raise SerializationError("stat_points must be provided.")
+            writer.add_short(data._stat_points)
+            if data._skill_points is None:
+                raise SerializationError("skill_points must be provided.")
+            writer.add_short(data._skill_points)
+            if data._hp is None:
+                raise SerializationError("hp must be provided.")
+            writer.add_short(data._hp)
+            if data._max_hp is None:
+                raise SerializationError("max_hp must be provided.")
+            writer.add_short(data._max_hp)
+            if data._tp is None:
+                raise SerializationError("tp must be provided.")
+            writer.add_short(data._tp)
+            if data._max_tp is None:
+                raise SerializationError("max_tp must be provided.")
+            writer.add_short(data._max_tp)
+            if data._max_sp is None:
+                raise SerializationError("max_sp must be provided.")
+            writer.add_short(data._max_sp)
+            if data._base is None:
+                raise SerializationError("base must be provided.")
+            CharacterBaseStats.serialize(writer, data._base)
+            if data._secondary is None:
+                raise SerializationError("secondary must be provided.")
+            CharacterSecondaryStats.serialize(writer, data._secondary)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CharacterStatsReset":