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

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

@@ -81,9 +81,13 @@ class StatSkillOpenClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (StatSkillOpenClientPacket): 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) -> "StatSkillOpenClientPacket":

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

@@ -98,12 +98,16 @@ class StatSkillRemoveClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (StatSkillRemoveClientPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_int(data._session_id)
-        if data._spell_id is None:
-            raise SerializationError("spell_id must be provided.")
-        writer.add_short(data._spell_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_int(data._session_id)
+            if data._spell_id is None:
+                raise SerializationError("spell_id must be provided.")
+            writer.add_short(data._spell_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "StatSkillRemoveClientPacket":

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

@@ -98,12 +98,16 @@ class StatSkillTakeClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (StatSkillTakeClientPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_int(data._session_id)
-        if data._spell_id is None:
-            raise SerializationError("spell_id must be provided.")
-        writer.add_short(data._spell_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_int(data._session_id)
+            if data._spell_id is None:
+                raise SerializationError("spell_id must be provided.")
+            writer.add_short(data._spell_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "StatSkillTakeClientPacket":

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -82,13 +82,19 @@ class TalkTellClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkTellClientPacket): The data to serialize.
         """
-        if data._name is None:
-            raise SerializationError("name must be provided.")
-        writer.add_string(data._name)
-        writer.add_byte(0xFF)
-        if data._message is None:
-            raise SerializationError("message must be provided.")
-        writer.add_string(data._message)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._name is None:
+                raise SerializationError("name must be provided.")
+            writer.add_string(data._name)
+            writer.add_byte(0xFF)
+            if data._message is None:
+                raise SerializationError("message must be provided.")
+            writer.add_string(data._message)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TalkTellClientPacket":

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

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

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

@@ -81,10 +81,14 @@ class TradeAcceptClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TradeAcceptClientPacket): The data to serialize.
         """
-        writer.add_char(0)
-        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(0)
+            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) -> "TradeAcceptClientPacket":

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

@@ -74,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

@@ -73,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

@@ -63,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":
@@ -82,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

@@ -81,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

@@ -81,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

@@ -74,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

@@ -74,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

@@ -74,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

@@ -98,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

@@ -98,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":