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

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class GuildReplyServerPacket(Packet):
+    """
+    Generic guild reply messages
+    """
     _byte_size: int = 0
     _reply_code: GuildReply = None # type: ignore [assignment]
     _reply_code_data: 'GuildReplyServerPacket.ReplyCodeData' = None
@@ -84,21 +87,25 @@ class GuildReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GuildReplyServerPacket): The data to serialize.
         """
-        if data._reply_code is None:
-            raise SerializationError("reply_code must be provided.")
-        writer.add_short(int(data._reply_code))
-        if data._reply_code == GuildReply.CreateAdd:
-            if not isinstance(data._reply_code_data, GuildReplyServerPacket.ReplyCodeDataCreateAdd):
-                raise SerializationError("Expected reply_code_data to be type GuildReplyServerPacket.ReplyCodeDataCreateAdd for reply_code " + GuildReply(data._reply_code).name + ".")
-            GuildReplyServerPacket.ReplyCodeDataCreateAdd.serialize(writer, data._reply_code_data)
-        elif data._reply_code == GuildReply.CreateAddConfirm:
-            if not isinstance(data._reply_code_data, GuildReplyServerPacket.ReplyCodeDataCreateAddConfirm):
-                raise SerializationError("Expected reply_code_data to be type GuildReplyServerPacket.ReplyCodeDataCreateAddConfirm for reply_code " + GuildReply(data._reply_code).name + ".")
-            GuildReplyServerPacket.ReplyCodeDataCreateAddConfirm.serialize(writer, data._reply_code_data)
-        elif data._reply_code == GuildReply.JoinRequest:
-            if not isinstance(data._reply_code_data, GuildReplyServerPacket.ReplyCodeDataJoinRequest):
-                raise SerializationError("Expected reply_code_data to be type GuildReplyServerPacket.ReplyCodeDataJoinRequest for reply_code " + GuildReply(data._reply_code).name + ".")
-            GuildReplyServerPacket.ReplyCodeDataJoinRequest.serialize(writer, data._reply_code_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._reply_code is None:
+                raise SerializationError("reply_code must be provided.")
+            writer.add_short(int(data._reply_code))
+            if data._reply_code == GuildReply.CreateAdd:
+                if not isinstance(data._reply_code_data, GuildReplyServerPacket.ReplyCodeDataCreateAdd):
+                    raise SerializationError("Expected reply_code_data to be type GuildReplyServerPacket.ReplyCodeDataCreateAdd for reply_code " + GuildReply(data._reply_code).name + ".")
+                GuildReplyServerPacket.ReplyCodeDataCreateAdd.serialize(writer, data._reply_code_data)
+            elif data._reply_code == GuildReply.CreateAddConfirm:
+                if not isinstance(data._reply_code_data, GuildReplyServerPacket.ReplyCodeDataCreateAddConfirm):
+                    raise SerializationError("Expected reply_code_data to be type GuildReplyServerPacket.ReplyCodeDataCreateAddConfirm for reply_code " + GuildReply(data._reply_code).name + ".")
+                GuildReplyServerPacket.ReplyCodeDataCreateAddConfirm.serialize(writer, data._reply_code_data)
+            elif data._reply_code == GuildReply.JoinRequest:
+                if not isinstance(data._reply_code_data, GuildReplyServerPacket.ReplyCodeDataJoinRequest):
+                    raise SerializationError("Expected reply_code_data to be type GuildReplyServerPacket.ReplyCodeDataJoinRequest for reply_code " + GuildReply(data._reply_code).name + ".")
+                GuildReplyServerPacket.ReplyCodeDataJoinRequest.serialize(writer, data._reply_code_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GuildReplyServerPacket":
@@ -131,10 +138,9 @@ class GuildReplyServerPacket(Packet):
         return f"GuildReplyServerPacket(byte_size={repr(self._byte_size)}, reply_code={repr(self._reply_code)}, reply_code_data={repr(self._reply_code_data)})"
 
     ReplyCodeData = Union['GuildReplyServerPacket.ReplyCodeDataCreateAdd', 'GuildReplyServerPacket.ReplyCodeDataCreateAddConfirm', 'GuildReplyServerPacket.ReplyCodeDataJoinRequest', None]
-    ReplyCodeData.__doc__ = \
-        """
-        Data associated with different values of the `reply_code` field.
-        """
+    """
+    Data associated with different values of the `reply_code` field.
+    """
 
     class ReplyCodeDataCreateAdd:
         """
@@ -170,9 +176,13 @@ class GuildReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (GuildReplyServerPacket.ReplyCodeDataCreateAdd): The data to serialize.
             """
-            if data._name is None:
-                raise SerializationError("name must be provided.")
-            writer.add_string(data._name)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._name is None:
+                    raise SerializationError("name must be provided.")
+                writer.add_string(data._name)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "GuildReplyServerPacket.ReplyCodeDataCreateAdd":
@@ -232,9 +242,13 @@ class GuildReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (GuildReplyServerPacket.ReplyCodeDataCreateAddConfirm): The data to serialize.
             """
-            if data._name is None:
-                raise SerializationError("name must be provided.")
-            writer.add_string(data._name)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._name is None:
+                    raise SerializationError("name must be provided.")
+                writer.add_string(data._name)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "GuildReplyServerPacket.ReplyCodeDataCreateAddConfirm":
@@ -311,12 +325,16 @@ class GuildReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (GuildReplyServerPacket.ReplyCodeDataJoinRequest): 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._name is None:
-                raise SerializationError("name must be provided.")
-            writer.add_string(data._name)
+            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._name is None:
+                    raise SerializationError("name must be provided.")
+                writer.add_string(data._name)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "GuildReplyServerPacket.ReplyCodeDataJoinRequest":

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class GuildReportServerPacket(Packet):
+    """
+    Get guild info reply
+    """
     _byte_size: int = 0
     _name: str = None # type: ignore [assignment]
     _tag: str = None # type: ignore [assignment]
@@ -144,46 +147,50 @@ class GuildReportServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GuildReportServerPacket): 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._tag is None:
-            raise SerializationError("tag must be provided.")
-        writer.add_string(data._tag)
-        writer.add_byte(0xFF)
-        if data._create_date is None:
-            raise SerializationError("create_date must be provided.")
-        writer.add_string(data._create_date)
-        writer.add_byte(0xFF)
-        if data._description is None:
-            raise SerializationError("description must be provided.")
-        writer.add_string(data._description)
-        writer.add_byte(0xFF)
-        if data._wealth is None:
-            raise SerializationError("wealth must be provided.")
-        writer.add_string(data._wealth)
-        writer.add_byte(0xFF)
-        if data._ranks is None:
-            raise SerializationError("ranks must be provided.")
-        if len(data._ranks) != 9:
-            raise SerializationError(f"Expected length of ranks to be exactly 9, got {len(data._ranks)}.")
-        for i in range(9):
-            if i > 0:
+        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._tag is None:
+                raise SerializationError("tag must be provided.")
+            writer.add_string(data._tag)
+            writer.add_byte(0xFF)
+            if data._create_date is None:
+                raise SerializationError("create_date must be provided.")
+            writer.add_string(data._create_date)
+            writer.add_byte(0xFF)
+            if data._description is None:
+                raise SerializationError("description must be provided.")
+            writer.add_string(data._description)
+            writer.add_byte(0xFF)
+            if data._wealth is None:
+                raise SerializationError("wealth must be provided.")
+            writer.add_string(data._wealth)
+            writer.add_byte(0xFF)
+            if data._ranks is None:
+                raise SerializationError("ranks must be provided.")
+            if len(data._ranks) != 9:
+                raise SerializationError(f"Expected length of ranks to be exactly 9, got {len(data._ranks)}.")
+            for i in range(9):
+                writer.add_string(data._ranks[i])
                 writer.add_byte(0xFF)
-            writer.add_string(data._ranks[i])
-        if data._staff_count is None:
-            raise SerializationError("staff_count must be provided.")
-        writer.add_short(data._staff_count)
-        writer.add_byte(0xFF)
-        if data._staff is None:
-            raise SerializationError("staff must be provided.")
-        if len(data._staff) > 64008:
-            raise SerializationError(f"Expected length of staff to be 64008 or less, got {len(data._staff)}.")
-        for i in range(data._staff_count):
-            if i > 0:
+            if data._staff_count is None:
+                raise SerializationError("staff_count must be provided.")
+            writer.add_short(data._staff_count)
+            writer.add_byte(0xFF)
+            if data._staff is None:
+                raise SerializationError("staff must be provided.")
+            if len(data._staff) > 64008:
+                raise SerializationError(f"Expected length of staff to be 64008 or less, got {len(data._staff)}.")
+            for i in range(data._staff_count):
+                GuildStaff.serialize(writer, data._staff[i])
                 writer.add_byte(0xFF)
-            GuildStaff.serialize(writer, data._staff[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GuildReportServerPacket":
@@ -214,15 +221,13 @@ class GuildReportServerPacket(Packet):
             data._ranks = []
             for i in range(9):
                 data._ranks.append(reader.get_string())
-                if i + 1 < 9:
-                    reader.next_chunk()
+                reader.next_chunk()
             data._staff_count = reader.get_short()
             reader.next_chunk()
             data._staff = []
             for i in range(data._staff_count):
                 data._staff.append(GuildStaff.deserialize(reader))
-                if i + 1 < data._staff_count:
-                    reader.next_chunk()
+                reader.next_chunk()
             reader.chunked_reading_mode = False
             data._byte_size = reader.position - reader_start_position
             return data

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class GuildRequestServerPacket(Packet):
+    """
+    Guild create request
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
     _guild_identity: str = None # type: ignore [assignment]
@@ -87,12 +90,16 @@ class GuildRequestServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GuildRequestServerPacket): 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._guild_identity is None:
-            raise SerializationError("guild_identity must be provided.")
-        writer.add_string(data._guild_identity)
+        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._guild_identity is None:
+                raise SerializationError("guild_identity must be provided.")
+            writer.add_string(data._guild_identity)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GuildRequestServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class GuildSellServerPacket(Packet):
+    """
+    Get guild bank reply
+    """
     _byte_size: int = 0
     _gold_amount: int = None # type: ignore [assignment]
 
@@ -78,9 +81,13 @@ class GuildSellServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GuildSellServerPacket): 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) -> "GuildSellServerPacket":

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

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

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class GuildTakeServerPacket(Packet):
+    """
+    Get guild description reply
+    """
     _byte_size: int = 0
     _description: str = None # type: ignore [assignment]
 
@@ -70,9 +73,13 @@ class GuildTakeServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GuildTakeServerPacket): The data to serialize.
         """
-        if data._description is None:
-            raise SerializationError("description must be provided.")
-        writer.add_string(data._description)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._description is None:
+                raise SerializationError("description must be provided.")
+            writer.add_string(data._description)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GuildTakeServerPacket":

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class GuildTellServerPacket(Packet):
+    """
+    Get guild member list reply
+    """
     _byte_size: int = 0
     _members_count: int = None # type: ignore [assignment]
     _members: list[GuildMember] = None # type: ignore [assignment]
@@ -82,18 +85,23 @@ class GuildTellServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GuildTellServerPacket): The data to serialize.
         """
-        if data._members_count is None:
-            raise SerializationError("members_count must be provided.")
-        writer.add_short(data._members_count)
-        writer.add_byte(0xFF)
-        if data._members is None:
-            raise SerializationError("members must be provided.")
-        if len(data._members) > 64008:
-            raise SerializationError(f"Expected length of members to be 64008 or less, got {len(data._members)}.")
-        for i in range(data._members_count):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._members_count is None:
+                raise SerializationError("members_count must be provided.")
+            writer.add_short(data._members_count)
+            writer.add_byte(0xFF)
+            if data._members is None:
+                raise SerializationError("members must be provided.")
+            if len(data._members) > 64008:
+                raise SerializationError(f"Expected length of members to be 64008 or less, got {len(data._members)}.")
+            for i in range(data._members_count):
+                GuildMember.serialize(writer, data._members[i])
                 writer.add_byte(0xFF)
-            GuildMember.serialize(writer, data._members[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GuildTellServerPacket":
@@ -116,8 +124,7 @@ class GuildTellServerPacket(Packet):
             data._members = []
             for i in range(data._members_count):
                 data._members.append(GuildMember.deserialize(reader))
-                if i + 1 < data._members_count:
-                    reader.next_chunk()
+                reader.next_chunk()
             reader.chunked_reading_mode = False
             data._byte_size = reader.position - reader_start_position
             return data

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

@@ -9,7 +9,7 @@ from ....protocol_enum_meta import ProtocolEnumMeta
 class InitBanType(IntEnum, metaclass=ProtocolEnumMeta):
     """
     Ban type sent with INIT_INIT packet.
-    The official client treats a value >= 2 as Permanent. Otherwise, it's Temporary.
+    The official client treats a value >= 2 as Permanent. Otherwise, it's Temporary.
     """
     Temporary = 1
     Permanent = 2