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

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TradeAddClientPacket(Packet):
+    """
+    Add an item to the trade screen
+    """
     _byte_size: int = 0
     _add_item: Item = None # type: ignore [assignment]
 
@@ -71,9 +74,13 @@ class TradeAddClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TradeAddClientPacket): The data to serialize.
         """
-        if data._add_item is None:
-            raise SerializationError("add_item must be provided.")
-        Item.serialize(writer, data._add_item)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._add_item is None:
+                raise SerializationError("add_item must be provided.")
+            Item.serialize(writer, data._add_item)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TradeAddClientPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TradeAgreeClientPacket(Packet):
+    """
+    Mark trade as agreed
+    """
     _byte_size: int = 0
     _agree: bool = None # type: ignore [assignment]
 
@@ -70,9 +73,13 @@ class TradeAgreeClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TradeAgreeClientPacket): The data to serialize.
         """
-        if data._agree is None:
-            raise SerializationError("agree must be provided.")
-        writer.add_char(1 if data._agree else 0)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._agree is None:
+                raise SerializationError("agree must be provided.")
+            writer.add_char(1 if data._agree else 0)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TradeAgreeClientPacket":

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

@@ -10,6 +10,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TradeCloseClientPacket(Packet):
+    """
+    Cancel the trade
+    """
     _byte_size: int = 0
 
     @property
@@ -60,9 +63,11 @@ class TradeCloseClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TradeCloseClientPacket): 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_char(0)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TradeCloseClientPacket":
@@ -79,8 +84,7 @@ class TradeCloseClientPacket(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_char()
+            reader.get_char()
             data._byte_size = reader.position - reader_start_position
             return data
         finally:

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

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

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TradeRequestClientPacket(Packet):
+    """
+    Requesting a trade with another player
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
 
@@ -78,10 +81,14 @@ class TradeRequestClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TradeRequestClientPacket): The data to serialize.
         """
-        writer.add_char(138)
-        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:
+            writer.add_char(138)
+            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) -> "TradeRequestClientPacket":

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

@@ -69,15 +69,19 @@ class WalkAction:
             writer (EoWriter): The writer that the data will be serialized to.
             data (WalkAction): The data to serialize.
         """
-        if data._direction is None:
-            raise SerializationError("direction must be provided.")
-        writer.add_char(int(data._direction))
-        if data._timestamp is None:
-            raise SerializationError("timestamp must be provided.")
-        writer.add_three(data._timestamp)
-        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._direction is None:
+                raise SerializationError("direction must be provided.")
+            writer.add_char(int(data._direction))
+            if data._timestamp is None:
+                raise SerializationError("timestamp must be provided.")
+            writer.add_three(data._timestamp)
+            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) -> "WalkAction":

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

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

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

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

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

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

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class WarpAcceptClientPacket(Packet):
+    """
+    Accept a warp request from the server
+    """
     _byte_size: int = 0
     _map_id: int = None # type: ignore [assignment]
     _session_id: int = None # type: ignore [assignment]
@@ -95,12 +98,16 @@ class WarpAcceptClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (WarpAcceptClientPacket): 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._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_short(data._session_id)
+        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._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_short(data._session_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "WarpAcceptClientPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class WarpTakeClientPacket(Packet):
+    """
+    Request to download a copy of the map
+    """
     _byte_size: int = 0
     _map_id: int = None # type: ignore [assignment]
     _session_id: int = None # type: ignore [assignment]
@@ -95,12 +98,16 @@ class WarpTakeClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (WarpTakeClientPacket): 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._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_short(data._session_id)
+        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._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_short(data._session_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "WarpTakeClientPacket":

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

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

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

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

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

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

eolib/protocol/_generated/net/item.py

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