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

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ItemGetServerPacket(Packet):
+    """
+    Reply to taking items from the ground
+    """
     _byte_size: int = 0
     _taken_item_index: int = None # type: ignore [assignment]
     _taken_item: ThreeItem = None # type: ignore [assignment]
@@ -98,15 +101,19 @@ class ItemGetServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ItemGetServerPacket): The data to serialize.
         """
-        if data._taken_item_index is None:
-            raise SerializationError("taken_item_index must be provided.")
-        writer.add_short(data._taken_item_index)
-        if data._taken_item is None:
-            raise SerializationError("taken_item must be provided.")
-        ThreeItem.serialize(writer, data._taken_item)
-        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._taken_item_index is None:
+                raise SerializationError("taken_item_index must be provided.")
+            writer.add_short(data._taken_item_index)
+            if data._taken_item is None:
+                raise SerializationError("taken_item must be provided.")
+            ThreeItem.serialize(writer, data._taken_item)
+            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) -> "ItemGetServerPacket":

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ItemJunkServerPacket(Packet):
+    """
+    Reply to junking items
+    """
     _byte_size: int = 0
     _junked_item: ThreeItem = None # type: ignore [assignment]
     _remaining_amount: int = None # type: ignore [assignment]
@@ -98,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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ItemKickServerPacket(Packet):
+    """
+    Lose item (from quest)
+    """
     _byte_size: int = 0
     _item: Item = None # type: ignore [assignment]
     _current_weight: int = None # type: ignore [assignment]
@@ -88,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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ItemObtainServerPacket(Packet):
+    """
+    Receive item (from quest)
+    """
     _byte_size: int = 0
     _item: ThreeItem = None # type: ignore [assignment]
     _current_weight: int = None # type: ignore [assignment]
@@ -88,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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ItemRemoveServerPacket(Packet):
+    """
+    Item disappeared from the ground
+    """
     _byte_size: int = 0
     _item_index: int = None # type: ignore [assignment]
 
@@ -78,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

@@ -16,6 +16,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ItemReplyServerPacket(Packet):
+    """
+    Reply to using an item
+    """
     _byte_size: int = 0
     _item_type: ItemType = None # type: ignore [assignment]
     _used_item: Item = None # type: ignore [assignment]
@@ -105,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":
@@ -172,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:
         """
@@ -253,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":
@@ -331,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":
@@ -401,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":
@@ -463,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":
@@ -533,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.
@@ -543,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.
@@ -639,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

@@ -10,6 +10,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ItemSpecServerPacket(Packet):
+    """
+    Reply to trying to take a protected item from the ground
+    """
     _byte_size: int = 0
 
     @property
@@ -60,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":
@@ -79,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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class JukeboxAgreeServerPacket(Packet):
+    """
+    Reply to successfully requesting a song
+    """
     _byte_size: int = 0
     _gold_amount: int = None # type: ignore [assignment]
 
@@ -78,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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class JukeboxMsgServerPacket(Packet):
+    """
+    Someone playing a note with the bard skill nearby
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
     _direction: Direction = None # type: ignore [assignment]
@@ -122,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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class JukeboxOpenServerPacket(Packet):
+    """
+    Reply to opening the jukebox listing
+    """
     _byte_size: int = 0
     _map_id: int = None # type: ignore [assignment]
     _jukebox_player: str = None # type: ignore [assignment]
@@ -87,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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class JukeboxPlayerServerPacket(Packet):
+    """
+    Play background music
+    """
     _byte_size: int = 0
     _mfx_id: int = None # type: ignore [assignment]
 
@@ -78,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":