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

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

@@ -101,15 +101,19 @@ class ItemJunkServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ItemJunkServerPacket): The data to serialize.
         """
-        if data._junked_item is None:
-            raise SerializationError("junked_item must be provided.")
-        ThreeItem.serialize(writer, data._junked_item)
-        if data._remaining_amount is None:
-            raise SerializationError("remaining_amount must be provided.")
-        writer.add_int(data._remaining_amount)
-        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:
+            if data._junked_item is None:
+                raise SerializationError("junked_item must be provided.")
+            ThreeItem.serialize(writer, data._junked_item)
+            if data._remaining_amount is None:
+                raise SerializationError("remaining_amount must be provided.")
+            writer.add_int(data._remaining_amount)
+            if data._weight is None:
+                raise SerializationError("weight must be provided.")
+            Weight.serialize(writer, data._weight)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ItemJunkServerPacket":

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

@@ -91,12 +91,16 @@ class ItemKickServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ItemKickServerPacket): The data to serialize.
         """
-        if data._item is None:
-            raise SerializationError("item must be provided.")
-        Item.serialize(writer, data._item)
-        if data._current_weight is None:
-            raise SerializationError("current_weight must be provided.")
-        writer.add_char(data._current_weight)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._item is None:
+                raise SerializationError("item must be provided.")
+            Item.serialize(writer, data._item)
+            if data._current_weight is None:
+                raise SerializationError("current_weight must be provided.")
+            writer.add_char(data._current_weight)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ItemKickServerPacket":

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

@@ -93,18 +93,22 @@ class ItemMapInfo:
             writer (EoWriter): The writer that the data will be serialized to.
             data (ItemMapInfo): The data to serialize.
         """
-        if data._uid is None:
-            raise SerializationError("uid must be provided.")
-        writer.add_short(data._uid)
-        if data._id is None:
-            raise SerializationError("id must be provided.")
-        writer.add_short(data._id)
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
-        if data._amount is None:
-            raise SerializationError("amount must be provided.")
-        writer.add_three(data._amount)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._uid is None:
+                raise SerializationError("uid must be provided.")
+            writer.add_short(data._uid)
+            if data._id is None:
+                raise SerializationError("id must be provided.")
+            writer.add_short(data._id)
+            if data._coords is None:
+                raise SerializationError("coords must be provided.")
+            Coords.serialize(writer, data._coords)
+            if data._amount is None:
+                raise SerializationError("amount must be provided.")
+            writer.add_three(data._amount)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ItemMapInfo":

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

@@ -91,12 +91,16 @@ class ItemObtainServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ItemObtainServerPacket): The data to serialize.
         """
-        if data._item is None:
-            raise SerializationError("item must be provided.")
-        ThreeItem.serialize(writer, data._item)
-        if data._current_weight is None:
-            raise SerializationError("current_weight must be provided.")
-        writer.add_char(data._current_weight)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._item is None:
+                raise SerializationError("item must be provided.")
+            ThreeItem.serialize(writer, data._item)
+            if data._current_weight is None:
+                raise SerializationError("current_weight must be provided.")
+            writer.add_char(data._current_weight)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ItemObtainServerPacket":

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

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

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

@@ -108,35 +108,39 @@ class ItemReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ItemReplyServerPacket): The data to serialize.
         """
-        if data._item_type is None:
-            raise SerializationError("item_type must be provided.")
-        writer.add_char(int(data._item_type))
-        if data._used_item is None:
-            raise SerializationError("used_item must be provided.")
-        Item.serialize(writer, data._used_item)
-        if data._weight is None:
-            raise SerializationError("weight must be provided.")
-        Weight.serialize(writer, data._weight)
-        if data._item_type == ItemType.Heal:
-            if not isinstance(data._item_type_data, ItemReplyServerPacket.ItemTypeDataHeal):
-                raise SerializationError("Expected item_type_data to be type ItemReplyServerPacket.ItemTypeDataHeal for item_type " + ItemType(data._item_type).name + ".")
-            ItemReplyServerPacket.ItemTypeDataHeal.serialize(writer, data._item_type_data)
-        elif data._item_type == ItemType.HairDye:
-            if not isinstance(data._item_type_data, ItemReplyServerPacket.ItemTypeDataHairDye):
-                raise SerializationError("Expected item_type_data to be type ItemReplyServerPacket.ItemTypeDataHairDye for item_type " + ItemType(data._item_type).name + ".")
-            ItemReplyServerPacket.ItemTypeDataHairDye.serialize(writer, data._item_type_data)
-        elif data._item_type == ItemType.EffectPotion:
-            if not isinstance(data._item_type_data, ItemReplyServerPacket.ItemTypeDataEffectPotion):
-                raise SerializationError("Expected item_type_data to be type ItemReplyServerPacket.ItemTypeDataEffectPotion for item_type " + ItemType(data._item_type).name + ".")
-            ItemReplyServerPacket.ItemTypeDataEffectPotion.serialize(writer, data._item_type_data)
-        elif data._item_type == ItemType.CureCurse:
-            if not isinstance(data._item_type_data, ItemReplyServerPacket.ItemTypeDataCureCurse):
-                raise SerializationError("Expected item_type_data to be type ItemReplyServerPacket.ItemTypeDataCureCurse for item_type " + ItemType(data._item_type).name + ".")
-            ItemReplyServerPacket.ItemTypeDataCureCurse.serialize(writer, data._item_type_data)
-        elif data._item_type == ItemType.ExpReward:
-            if not isinstance(data._item_type_data, ItemReplyServerPacket.ItemTypeDataExpReward):
-                raise SerializationError("Expected item_type_data to be type ItemReplyServerPacket.ItemTypeDataExpReward for item_type " + ItemType(data._item_type).name + ".")
-            ItemReplyServerPacket.ItemTypeDataExpReward.serialize(writer, data._item_type_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._item_type is None:
+                raise SerializationError("item_type must be provided.")
+            writer.add_char(int(data._item_type))
+            if data._used_item is None:
+                raise SerializationError("used_item must be provided.")
+            Item.serialize(writer, data._used_item)
+            if data._weight is None:
+                raise SerializationError("weight must be provided.")
+            Weight.serialize(writer, data._weight)
+            if data._item_type == ItemType.Heal:
+                if not isinstance(data._item_type_data, ItemReplyServerPacket.ItemTypeDataHeal):
+                    raise SerializationError("Expected item_type_data to be type ItemReplyServerPacket.ItemTypeDataHeal for item_type " + ItemType(data._item_type).name + ".")
+                ItemReplyServerPacket.ItemTypeDataHeal.serialize(writer, data._item_type_data)
+            elif data._item_type == ItemType.HairDye:
+                if not isinstance(data._item_type_data, ItemReplyServerPacket.ItemTypeDataHairDye):
+                    raise SerializationError("Expected item_type_data to be type ItemReplyServerPacket.ItemTypeDataHairDye for item_type " + ItemType(data._item_type).name + ".")
+                ItemReplyServerPacket.ItemTypeDataHairDye.serialize(writer, data._item_type_data)
+            elif data._item_type == ItemType.EffectPotion:
+                if not isinstance(data._item_type_data, ItemReplyServerPacket.ItemTypeDataEffectPotion):
+                    raise SerializationError("Expected item_type_data to be type ItemReplyServerPacket.ItemTypeDataEffectPotion for item_type " + ItemType(data._item_type).name + ".")
+                ItemReplyServerPacket.ItemTypeDataEffectPotion.serialize(writer, data._item_type_data)
+            elif data._item_type == ItemType.CureCurse:
+                if not isinstance(data._item_type_data, ItemReplyServerPacket.ItemTypeDataCureCurse):
+                    raise SerializationError("Expected item_type_data to be type ItemReplyServerPacket.ItemTypeDataCureCurse for item_type " + ItemType(data._item_type).name + ".")
+                ItemReplyServerPacket.ItemTypeDataCureCurse.serialize(writer, data._item_type_data)
+            elif data._item_type == ItemType.ExpReward:
+                if not isinstance(data._item_type_data, ItemReplyServerPacket.ItemTypeDataExpReward):
+                    raise SerializationError("Expected item_type_data to be type ItemReplyServerPacket.ItemTypeDataExpReward for item_type " + ItemType(data._item_type).name + ".")
+                ItemReplyServerPacket.ItemTypeDataExpReward.serialize(writer, data._item_type_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ItemReplyServerPacket":
@@ -175,10 +179,9 @@ class ItemReplyServerPacket(Packet):
         return f"ItemReplyServerPacket(byte_size={repr(self._byte_size)}, item_type={repr(self._item_type)}, used_item={repr(self._used_item)}, weight={repr(self._weight)}, item_type_data={repr(self._item_type_data)})"
 
     ItemTypeData = Union['ItemReplyServerPacket.ItemTypeDataHeal', 'ItemReplyServerPacket.ItemTypeDataHairDye', 'ItemReplyServerPacket.ItemTypeDataEffectPotion', 'ItemReplyServerPacket.ItemTypeDataCureCurse', 'ItemReplyServerPacket.ItemTypeDataExpReward', None]
-    ItemTypeData.__doc__ = \
-        """
-        Data associated with different values of the `item_type` field.
-        """
+    """
+    Data associated with different values of the `item_type` field.
+    """
 
     class ItemTypeDataHeal:
         """
@@ -256,15 +259,19 @@ class ItemReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (ItemReplyServerPacket.ItemTypeDataHeal): The data to serialize.
             """
-            if data._hp_gain is None:
-                raise SerializationError("hp_gain must be provided.")
-            writer.add_int(data._hp_gain)
-            if data._hp is None:
-                raise SerializationError("hp must be provided.")
-            writer.add_short(data._hp)
-            if data._tp is None:
-                raise SerializationError("tp must be provided.")
-            writer.add_short(data._tp)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._hp_gain is None:
+                    raise SerializationError("hp_gain must be provided.")
+                writer.add_int(data._hp_gain)
+                if data._hp is None:
+                    raise SerializationError("hp must be provided.")
+                writer.add_short(data._hp)
+                if data._tp is None:
+                    raise SerializationError("tp must be provided.")
+                writer.add_short(data._tp)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "ItemReplyServerPacket.ItemTypeDataHeal":
@@ -334,9 +341,13 @@ class ItemReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (ItemReplyServerPacket.ItemTypeDataHairDye): The data to serialize.
             """
-            if data._hair_color is None:
-                raise SerializationError("hair_color must be provided.")
-            writer.add_char(data._hair_color)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._hair_color is None:
+                    raise SerializationError("hair_color must be provided.")
+                writer.add_char(data._hair_color)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "ItemReplyServerPacket.ItemTypeDataHairDye":
@@ -404,9 +415,13 @@ class ItemReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (ItemReplyServerPacket.ItemTypeDataEffectPotion): The data to serialize.
             """
-            if data._effect_id is None:
-                raise SerializationError("effect_id must be provided.")
-            writer.add_short(data._effect_id)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._effect_id is None:
+                    raise SerializationError("effect_id must be provided.")
+                writer.add_short(data._effect_id)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "ItemReplyServerPacket.ItemTypeDataEffectPotion":
@@ -466,9 +481,13 @@ class ItemReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (ItemReplyServerPacket.ItemTypeDataCureCurse): The data to serialize.
             """
-            if data._stats is None:
-                raise SerializationError("stats must be provided.")
-            CharacterStatsEquipmentChange.serialize(writer, data._stats)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._stats is None:
+                    raise SerializationError("stats must be provided.")
+                CharacterStatsEquipmentChange.serialize(writer, data._stats)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "ItemReplyServerPacket.ItemTypeDataCureCurse":
@@ -536,7 +555,7 @@ class ItemReplyServerPacket(Packet):
         @property
         def level_up(self) -> int:
             """
-            A value greater than 0 is "new level" and indicates the player leveled up.
+            A value greater than 0 is "new level" and indicates the player leveled up.
 
             Note:
               - Value range is 0-252.
@@ -546,7 +565,7 @@ class ItemReplyServerPacket(Packet):
         @level_up.setter
         def level_up(self, level_up: int) -> None:
             """
-            A value greater than 0 is "new level" and indicates the player leveled up.
+            A value greater than 0 is "new level" and indicates the player leveled up.
 
             Note:
               - Value range is 0-252.
@@ -642,27 +661,31 @@ class ItemReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (ItemReplyServerPacket.ItemTypeDataExpReward): The data to serialize.
             """
-            if data._experience is None:
-                raise SerializationError("experience must be provided.")
-            writer.add_int(data._experience)
-            if data._level_up is None:
-                raise SerializationError("level_up must be provided.")
-            writer.add_char(data._level_up)
-            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._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._max_sp is None:
-                raise SerializationError("max_sp must be provided.")
-            writer.add_short(data._max_sp)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._experience is None:
+                    raise SerializationError("experience must be provided.")
+                writer.add_int(data._experience)
+                if data._level_up is None:
+                    raise SerializationError("level_up must be provided.")
+                writer.add_char(data._level_up)
+                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._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._max_sp is None:
+                    raise SerializationError("max_sp must be provided.")
+                writer.add_short(data._max_sp)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "ItemReplyServerPacket.ItemTypeDataExpReward":

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

@@ -63,9 +63,11 @@ class ItemSpecServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ItemSpecServerPacket): The data to serialize.
         """
-        old_writer_length: int = len(writer)
-        if len(writer) == old_writer_length:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
             writer.add_short(2)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ItemSpecServerPacket":
@@ -82,8 +84,7 @@ class ItemSpecServerPacket(Packet):
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            if reader.position == reader_start_position:
-                reader.get_short()
+            reader.get_short()
             data._byte_size = reader.position - reader_start_position
             return data
         finally:

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

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

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

@@ -125,18 +125,22 @@ class JukeboxMsgServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (JukeboxMsgServerPacket): The data to serialize.
         """
-        if data._player_id is None:
-            raise SerializationError("player_id must be provided.")
-        writer.add_short(data._player_id)
-        if data._direction is None:
-            raise SerializationError("direction must be provided.")
-        writer.add_char(int(data._direction))
-        if data._instrument_id is None:
-            raise SerializationError("instrument_id must be provided.")
-        writer.add_char(data._instrument_id)
-        if data._note_id is None:
-            raise SerializationError("note_id must be provided.")
-        writer.add_char(data._note_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)
+            if data._direction is None:
+                raise SerializationError("direction must be provided.")
+            writer.add_char(int(data._direction))
+            if data._instrument_id is None:
+                raise SerializationError("instrument_id must be provided.")
+            writer.add_char(data._instrument_id)
+            if data._note_id is None:
+                raise SerializationError("note_id must be provided.")
+            writer.add_char(data._note_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "JukeboxMsgServerPacket":

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

@@ -90,12 +90,16 @@ class JukeboxOpenServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (JukeboxOpenServerPacket): The data to serialize.
         """
-        if data._map_id is None:
-            raise SerializationError("map_id must be provided.")
-        writer.add_short(data._map_id)
-        if data._jukebox_player is None:
-            raise SerializationError("jukebox_player must be provided.")
-        writer.add_string(data._jukebox_player)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._map_id is None:
+                raise SerializationError("map_id must be provided.")
+            writer.add_short(data._map_id)
+            if data._jukebox_player is None:
+                raise SerializationError("jukebox_player must be provided.")
+            writer.add_string(data._jukebox_player)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "JukeboxOpenServerPacket":

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

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

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

@@ -63,9 +63,11 @@ class JukeboxReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (JukeboxReplyServerPacket): The data to serialize.
         """
-        old_writer_length: int = len(writer)
-        if len(writer) == old_writer_length:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
             writer.add_short(1)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "JukeboxReplyServerPacket":
@@ -82,8 +84,7 @@ class JukeboxReplyServerPacket(Packet):
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            if reader.position == reader_start_position:
-                reader.get_short()
+            reader.get_short()
             data._byte_size = reader.position - reader_start_position
             return data
         finally:

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

@@ -30,6 +30,8 @@ class JukeboxUseServerPacket(Packet):
     @property
     def track_id(self) -> int:
         """
+        This value is 1-indexed
+
         Note:
           - Value range is 0-64008.
         """
@@ -38,6 +40,8 @@ class JukeboxUseServerPacket(Packet):
     @track_id.setter
     def track_id(self, track_id: int) -> None:
         """
+        This value is 1-indexed
+
         Note:
           - Value range is 0-64008.
         """
@@ -81,9 +85,13 @@ class JukeboxUseServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (JukeboxUseServerPacket): The data to serialize.
         """
-        if data._track_id is None:
-            raise SerializationError("track_id must be provided.")
-        writer.add_short(data._track_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._track_id is None:
+                raise SerializationError("track_id must be provided.")
+            writer.add_short(data._track_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "JukeboxUseServerPacket":

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

@@ -134,24 +134,28 @@ class LevelUpStats:
             writer (EoWriter): The writer that the data will be serialized to.
             data (LevelUpStats): The data to serialize.
         """
-        if data._level is None:
-            raise SerializationError("level must be provided.")
-        writer.add_char(data._level)
-        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._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._max_sp is None:
-            raise SerializationError("max_sp must be provided.")
-        writer.add_short(data._max_sp)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._level is None:
+                raise SerializationError("level must be provided.")
+            writer.add_char(data._level)
+            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._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._max_sp is None:
+                raise SerializationError("max_sp must be provided.")
+            writer.add_short(data._max_sp)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "LevelUpStats":

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

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