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

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class BoardOpenClientPacket(Packet):
+    """
+    Opening a town board
+    """
     _byte_size: int = 0
     _board_id: int = None # type: ignore [assignment]
 
@@ -78,9 +81,13 @@ class BoardOpenClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (BoardOpenClientPacket): The data to serialize.
         """
-        if data._board_id is None:
-            raise SerializationError("board_id must be provided.")
-        writer.add_short(data._board_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._board_id is None:
+                raise SerializationError("board_id must be provided.")
+            writer.add_short(data._board_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "BoardOpenClientPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class BoardRemoveClientPacket(Packet):
+    """
+    Removing a post from a town board
+    """
     _byte_size: int = 0
     _board_id: int = None # type: ignore [assignment]
     _post_id: int = None # type: ignore [assignment]
@@ -95,12 +98,16 @@ class BoardRemoveClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (BoardRemoveClientPacket): The data to serialize.
         """
-        if data._board_id is None:
-            raise SerializationError("board_id must be provided.")
-        writer.add_short(data._board_id)
-        if data._post_id is None:
-            raise SerializationError("post_id must be provided.")
-        writer.add_short(data._post_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._board_id is None:
+                raise SerializationError("board_id must be provided.")
+            writer.add_short(data._board_id)
+            if data._post_id is None:
+                raise SerializationError("post_id must be provided.")
+            writer.add_short(data._post_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "BoardRemoveClientPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class BoardTakeClientPacket(Packet):
+    """
+    Reading a post on a town board
+    """
     _byte_size: int = 0
     _board_id: int = None # type: ignore [assignment]
     _post_id: int = None # type: ignore [assignment]
@@ -95,12 +98,16 @@ class BoardTakeClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (BoardTakeClientPacket): The data to serialize.
         """
-        if data._board_id is None:
-            raise SerializationError("board_id must be provided.")
-        writer.add_short(data._board_id)
-        if data._post_id is None:
-            raise SerializationError("post_id must be provided.")
-        writer.add_short(data._post_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._board_id is None:
+                raise SerializationError("board_id must be provided.")
+            writer.add_short(data._board_id)
+            if data._post_id is None:
+                raise SerializationError("post_id must be provided.")
+            writer.add_short(data._post_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "BoardTakeClientPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class BookRequestClientPacket(Packet):
+    """
+    Request for a player's book
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
 
@@ -78,9 +81,13 @@ class BookRequestClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (BookRequestClientPacket): The data to serialize.
         """
-        if data._player_id is None:
-            raise SerializationError("player_id must be provided.")
-        writer.add_short(data._player_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._player_id is None:
+                raise SerializationError("player_id must be provided.")
+            writer.add_short(data._player_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "BookRequestClientPacket":

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

@@ -66,12 +66,16 @@ class ByteCoords:
             writer (EoWriter): The writer that the data will be serialized to.
             data (ByteCoords): The data to serialize.
         """
-        if data._x is None:
-            raise SerializationError("x must be provided.")
-        writer.add_byte(data._x)
-        if data._y is None:
-            raise SerializationError("y must be provided.")
-        writer.add_byte(data._y)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._x is None:
+                raise SerializationError("x must be provided.")
+            writer.add_byte(data._x)
+            if data._y is None:
+                raise SerializationError("y must be provided.")
+            writer.add_byte(data._y)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ByteCoords":

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

@@ -14,6 +14,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ChairRequestClientPacket(Packet):
+    """
+    Sitting on a chair
+    """
     _byte_size: int = 0
     _sit_action: SitAction = None # type: ignore [assignment]
     _sit_action_data: 'ChairRequestClientPacket.SitActionData' = None
@@ -85,13 +88,17 @@ class ChairRequestClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ChairRequestClientPacket): The data to serialize.
         """
-        if data._sit_action is None:
-            raise SerializationError("sit_action must be provided.")
-        writer.add_char(int(data._sit_action))
-        if data._sit_action == SitAction.Sit:
-            if not isinstance(data._sit_action_data, ChairRequestClientPacket.SitActionDataSit):
-                raise SerializationError("Expected sit_action_data to be type ChairRequestClientPacket.SitActionDataSit for sit_action " + SitAction(data._sit_action).name + ".")
-            ChairRequestClientPacket.SitActionDataSit.serialize(writer, data._sit_action_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._sit_action is None:
+                raise SerializationError("sit_action must be provided.")
+            writer.add_char(int(data._sit_action))
+            if data._sit_action == SitAction.Sit:
+                if not isinstance(data._sit_action_data, ChairRequestClientPacket.SitActionDataSit):
+                    raise SerializationError("Expected sit_action_data to be type ChairRequestClientPacket.SitActionDataSit for sit_action " + SitAction(data._sit_action).name + ".")
+                ChairRequestClientPacket.SitActionDataSit.serialize(writer, data._sit_action_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ChairRequestClientPacket":
@@ -120,10 +127,9 @@ class ChairRequestClientPacket(Packet):
         return f"ChairRequestClientPacket(byte_size={repr(self._byte_size)}, sit_action={repr(self._sit_action)}, sit_action_data={repr(self._sit_action_data)})"
 
     SitActionData = Union['ChairRequestClientPacket.SitActionDataSit', None]
-    SitActionData.__doc__ = \
-        """
-        Data associated with different values of the `sit_action` field.
-        """
+    """
+    Data associated with different values of the `sit_action` field.
+    """
 
     class SitActionDataSit:
         """
@@ -159,9 +165,13 @@ class ChairRequestClientPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (ChairRequestClientPacket.SitActionDataSit): The data to serialize.
             """
-            if data._coords is None:
-                raise SerializationError("coords must be provided.")
-            Coords.serialize(writer, data._coords)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._coords is None:
+                    raise SerializationError("coords must be provided.")
+                Coords.serialize(writer, data._coords)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "ChairRequestClientPacket.SitActionDataSit":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class CharacterCreateClientPacket(Packet):
+    """
+    Confirm creating a character
+    """
     _byte_size: int = 0
     _session_id: int = None # type: ignore [assignment]
     _gender: Gender = None # type: ignore [assignment]
@@ -148,26 +151,32 @@ class CharacterCreateClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CharacterCreateClientPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_short(data._session_id)
-        if data._gender is None:
-            raise SerializationError("gender must be provided.")
-        writer.add_short(int(data._gender))
-        if data._hair_style is None:
-            raise SerializationError("hair_style must be provided.")
-        writer.add_short(data._hair_style)
-        if data._hair_color is None:
-            raise SerializationError("hair_color must be provided.")
-        writer.add_short(data._hair_color)
-        if data._skin is None:
-            raise SerializationError("skin must be provided.")
-        writer.add_short(data._skin)
-        writer.add_byte(0xFF)
-        if data._name is None:
-            raise SerializationError("name must be provided.")
-        writer.add_string(data._name)
-        writer.add_byte(0xFF)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_short(data._session_id)
+            if data._gender is None:
+                raise SerializationError("gender must be provided.")
+            writer.add_short(int(data._gender))
+            if data._hair_style is None:
+                raise SerializationError("hair_style must be provided.")
+            writer.add_short(data._hair_style)
+            if data._hair_color is None:
+                raise SerializationError("hair_color must be provided.")
+            writer.add_short(data._hair_color)
+            if data._skin is None:
+                raise SerializationError("skin must be provided.")
+            writer.add_short(data._skin)
+            writer.add_byte(0xFF)
+            if data._name is None:
+                raise SerializationError("name must be provided.")
+            writer.add_string(data._name)
+            writer.add_byte(0xFF)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CharacterCreateClientPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class CharacterRemoveClientPacket(Packet):
+    """
+    Confirm deleting character from an account
+    """
     _byte_size: int = 0
     _session_id: int = None # type: ignore [assignment]
     _character_id: int = None # type: ignore [assignment]
@@ -95,12 +98,16 @@ class CharacterRemoveClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CharacterRemoveClientPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_short(data._session_id)
-        if data._character_id is None:
-            raise SerializationError("character_id must be provided.")
-        writer.add_int(data._character_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_short(data._session_id)
+            if data._character_id is None:
+                raise SerializationError("character_id must be provided.")
+            writer.add_int(data._character_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CharacterRemoveClientPacket":

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

@@ -10,6 +10,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class CharacterRequestClientPacket(Packet):
+    """
+    Request to create a character
+    """
     _byte_size: int = 0
     _request_string: str = "NEW" # type: ignore [assignment]
 
@@ -65,8 +68,14 @@ class CharacterRequestClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CharacterRequestClientPacket): The data to serialize.
         """
-        writer.add_string(data._request_string)
-        writer.add_byte(0xFF)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            writer.add_string(data._request_string)
+            writer.add_byte(0xFF)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CharacterRequestClientPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class CharacterTakeClientPacket(Packet):
+    """
+    Request to delete a character from an account
+    """
     _byte_size: int = 0
     _character_id: int = None # type: ignore [assignment]
 
@@ -78,9 +81,13 @@ class CharacterTakeClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CharacterTakeClientPacket): The data to serialize.
         """
-        if data._character_id is None:
-            raise SerializationError("character_id must be provided.")
-        writer.add_int(data._character_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._character_id is None:
+                raise SerializationError("character_id must be provided.")
+            writer.add_int(data._character_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CharacterTakeClientPacket":

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ChestAddClientPacket(Packet):
+    """
+    Placing an item in to a chest
+    """
     _byte_size: int = 0
     _coords: Coords = None # type: ignore [assignment]
     _add_item: ThreeItem = None # type: ignore [assignment]
@@ -81,12 +84,16 @@ class ChestAddClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ChestAddClientPacket): The data to serialize.
         """
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
-        if data._add_item is None:
-            raise SerializationError("add_item must be provided.")
-        ThreeItem.serialize(writer, data._add_item)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._coords is None:
+                raise SerializationError("coords must be provided.")
+            Coords.serialize(writer, data._coords)
+            if data._add_item is None:
+                raise SerializationError("add_item must be provided.")
+            ThreeItem.serialize(writer, data._add_item)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ChestAddClientPacket":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ChestOpenClientPacket(Packet):
+    """
+    Opening a chest
+    """
     _byte_size: int = 0
     _coords: Coords = None # type: ignore [assignment]
 
@@ -71,9 +74,13 @@ class ChestOpenClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ChestOpenClientPacket): The data to serialize.
         """
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._coords is None:
+                raise SerializationError("coords must be provided.")
+            Coords.serialize(writer, data._coords)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ChestOpenClientPacket":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ChestTakeClientPacket(Packet):
+    """
+    Taking an item from a chest
+    """
     _byte_size: int = 0
     _coords: Coords = None # type: ignore [assignment]
     _take_item_id: int = None # type: ignore [assignment]
@@ -88,12 +91,16 @@ class ChestTakeClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ChestTakeClientPacket): The data to serialize.
         """
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
-        if data._take_item_id is None:
-            raise SerializationError("take_item_id must be provided.")
-        writer.add_short(data._take_item_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._coords is None:
+                raise SerializationError("coords must be provided.")
+            Coords.serialize(writer, data._coords)
+            if data._take_item_id is None:
+                raise SerializationError("take_item_id must be provided.")
+            writer.add_short(data._take_item_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ChestTakeClientPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class CitizenAcceptClientPacket(Packet):
+    """
+    Confirm sleeping at an inn
+    """
     _byte_size: int = 0
     _session_id: int = None # type: ignore [assignment]
     _behavior_id: int = None # type: ignore [assignment]
@@ -95,12 +98,16 @@ class CitizenAcceptClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CitizenAcceptClientPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_short(data._session_id)
-        if data._behavior_id is None:
-            raise SerializationError("behavior_id must be provided.")
-        writer.add_short(data._behavior_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_short(data._session_id)
+            if data._behavior_id is None:
+                raise SerializationError("behavior_id must be provided.")
+            writer.add_short(data._behavior_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CitizenAcceptClientPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class CitizenOpenClientPacket(Packet):
+    """
+    Talking to a citizenship NPC
+    """
     _byte_size: int = 0
     _npc_index: int = None # type: ignore [assignment]
 
@@ -78,9 +81,13 @@ class CitizenOpenClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CitizenOpenClientPacket): The data to serialize.
         """
-        if data._npc_index is None:
-            raise SerializationError("npc_index must be provided.")
-        writer.add_short(data._npc_index)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._npc_index is None:
+                raise SerializationError("npc_index must be provided.")
+            writer.add_short(data._npc_index)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CitizenOpenClientPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class CitizenRemoveClientPacket(Packet):
+    """
+    Giving up citizenship of a town
+    """
     _byte_size: int = 0
     _behavior_id: int = None # type: ignore [assignment]
 
@@ -78,9 +81,13 @@ class CitizenRemoveClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CitizenRemoveClientPacket): The data to serialize.
         """
-        if data._behavior_id is None:
-            raise SerializationError("behavior_id must be provided.")
-        writer.add_short(data._behavior_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._behavior_id is None:
+                raise SerializationError("behavior_id must be provided.")
+            writer.add_short(data._behavior_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CitizenRemoveClientPacket":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class CitizenReplyClientPacket(Packet):
+    """
+    Subscribing to a town
+    """
     _byte_size: int = 0
     _session_id: int = None # type: ignore [assignment]
     _behavior_id: int = None # type: ignore [assignment]
@@ -113,22 +116,28 @@ class CitizenReplyClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CitizenReplyClientPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_short(data._session_id)
-        writer.add_byte(0xFF)
-        if data._behavior_id is None:
-            raise SerializationError("behavior_id must be provided.")
-        writer.add_short(data._behavior_id)
-        writer.add_byte(0xFF)
-        if data._answers is None:
-            raise SerializationError("answers must be provided.")
-        if len(data._answers) != 3:
-            raise SerializationError(f"Expected length of answers to be exactly 3, got {len(data._answers)}.")
-        for i in range(3):
-            if i > 0:
-                writer.add_byte(0xFF)
-            writer.add_string(data._answers[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_short(data._session_id)
+            writer.add_byte(0xFF)
+            if data._behavior_id is None:
+                raise SerializationError("behavior_id must be provided.")
+            writer.add_short(data._behavior_id)
+            writer.add_byte(0xFF)
+            if data._answers is None:
+                raise SerializationError("answers must be provided.")
+            if len(data._answers) != 3:
+                raise SerializationError(f"Expected length of answers to be exactly 3, got {len(data._answers)}.")
+            for i in range(3):
+                if i > 0:
+                    writer.add_byte(0xFF)
+                writer.add_string(data._answers[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CitizenReplyClientPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class CitizenRequestClientPacket(Packet):
+    """
+    Request sleeping at an inn
+    """
     _byte_size: int = 0
     _session_id: int = None # type: ignore [assignment]
     _behavior_id: int = None # type: ignore [assignment]
@@ -95,12 +98,16 @@ class CitizenRequestClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CitizenRequestClientPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_short(data._session_id)
-        if data._behavior_id is None:
-            raise SerializationError("behavior_id must be provided.")
-        writer.add_short(data._behavior_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_short(data._session_id)
+            if data._behavior_id is None:
+                raise SerializationError("behavior_id must be provided.")
+            writer.add_short(data._behavior_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CitizenRequestClientPacket":