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

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

@@ -4,6 +4,7 @@
 # Changes will be lost when code is regenerated.
 
 from __future__ import annotations
+from collections.abc import Iterable
 from .guild_staff import GuildStaff
 from ..packet_family import PacketFamily
 from ..packet_action import PacketAction
@@ -17,14 +18,36 @@ class GuildReportServerPacket(Packet):
     Get guild info reply
     """
     _byte_size: int = 0
-    _name: str = None # type: ignore [assignment]
-    _tag: str = None # type: ignore [assignment]
-    _create_date: str = None # type: ignore [assignment]
-    _description: str = None # type: ignore [assignment]
-    _wealth: str = None # type: ignore [assignment]
-    _ranks: list[str] = None # type: ignore [assignment]
-    _staff_count: int = None # type: ignore [assignment]
-    _staff: list[GuildStaff] = None # type: ignore [assignment]
+    _name: str
+    _tag: str
+    _create_date: str
+    _description: str
+    _wealth: str
+    _ranks: tuple[str, ...]
+    _staff_count: int
+    _staff: tuple[GuildStaff, ...]
+
+    def __init__(self, *, name: str, tag: str, create_date: str, description: str, wealth: str, ranks: Iterable[str], staff: Iterable[GuildStaff]):
+        """
+        Create a new instance of GuildReportServerPacket.
+
+        Args:
+            name (str): 
+            tag (str): 
+            create_date (str): 
+            description (str): 
+            wealth (str): 
+            ranks (Iterable[str]): (Length must be `9`.)
+            staff (Iterable[GuildStaff]): (Length must be 64008 or less.)
+        """
+        self._name = name
+        self._tag = tag
+        self._create_date = create_date
+        self._description = description
+        self._wealth = wealth
+        self._ranks = tuple(ranks)
+        self._staff = tuple(staff)
+        self._staff_count = len(self._staff)
 
     @property
     def byte_size(self) -> int:
@@ -40,75 +63,30 @@ class GuildReportServerPacket(Packet):
     def name(self) -> str:
         return self._name
 
-    @name.setter
-    def name(self, name: str) -> None:
-        self._name = name
-
     @property
     def tag(self) -> str:
         return self._tag
 
-    @tag.setter
-    def tag(self, tag: str) -> None:
-        self._tag = tag
-
     @property
     def create_date(self) -> str:
         return self._create_date
 
-    @create_date.setter
-    def create_date(self, create_date: str) -> None:
-        self._create_date = create_date
-
     @property
     def description(self) -> str:
         return self._description
 
-    @description.setter
-    def description(self, description: str) -> None:
-        self._description = description
-
     @property
     def wealth(self) -> str:
         return self._wealth
 
-    @wealth.setter
-    def wealth(self, wealth: str) -> None:
-        self._wealth = wealth
-
     @property
-    def ranks(self) -> list[str]:
-        """
-        Note:
-          - Length must be `9`.
-        """
+    def ranks(self) -> tuple[str, ...]:
         return self._ranks
 
-    @ranks.setter
-    def ranks(self, ranks: list[str]) -> None:
-        """
-        Note:
-          - Length must be `9`.
-        """
-        self._ranks = ranks
-
     @property
-    def staff(self) -> list[GuildStaff]:
-        """
-        Note:
-          - Length must be 64008 or less.
-        """
+    def staff(self) -> tuple[GuildStaff, ...]:
         return self._staff
 
-    @staff.setter
-    def staff(self, staff: list[GuildStaff]) -> None:
-        """
-        Note:
-          - Length must be 64008 or less.
-        """
-        self._staff = staff
-        self._staff_count = len(self._staff)
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -147,46 +125,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":
@@ -199,36 +181,34 @@ class GuildReportServerPacket(Packet):
         Returns:
             GuildReportServerPacket: The data to serialize.
         """
-        data: GuildReportServerPacket = GuildReportServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
-            data._name = reader.get_string()
+            name = reader.get_string()
             reader.next_chunk()
-            data._tag = reader.get_string()
+            tag = reader.get_string()
             reader.next_chunk()
-            data._create_date = reader.get_string()
+            create_date = reader.get_string()
             reader.next_chunk()
-            data._description = reader.get_string()
+            description = reader.get_string()
             reader.next_chunk()
-            data._wealth = reader.get_string()
+            wealth = reader.get_string()
             reader.next_chunk()
-            data._ranks = []
+            ranks = []
             for i in range(9):
-                data._ranks.append(reader.get_string())
-                if i + 1 < 9:
-                    reader.next_chunk()
-            data._staff_count = reader.get_short()
+                ranks.append(reader.get_string())
+                reader.next_chunk()
+            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()
+            staff = []
+            for i in range(staff_count):
+                staff.append(GuildStaff.deserialize(reader))
+                reader.next_chunk()
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = GuildReportServerPacket(name=name, tag=tag, create_date=create_date, description=description, wealth=wealth, ranks=ranks, staff=staff)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -15,8 +15,19 @@ class GuildRequestServerPacket(Packet):
     Guild create request
     """
     _byte_size: int = 0
-    _player_id: int = None # type: ignore [assignment]
-    _guild_identity: str = None # type: ignore [assignment]
+    _player_id: int
+    _guild_identity: str
+
+    def __init__(self, *, player_id: int, guild_identity: str):
+        """
+        Create a new instance of GuildRequestServerPacket.
+
+        Args:
+            player_id (int): (Value range is 0-64008.)
+            guild_identity (str): 
+        """
+        self._player_id = player_id
+        self._guild_identity = guild_identity
 
     @property
     def byte_size(self) -> int:
@@ -30,28 +41,12 @@ class GuildRequestServerPacket(Packet):
 
     @property
     def player_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._player_id
 
-    @player_id.setter
-    def player_id(self, player_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._player_id = player_id
-
     @property
     def guild_identity(self) -> str:
         return self._guild_identity
 
-    @guild_identity.setter
-    def guild_identity(self, guild_identity: str) -> None:
-        self._guild_identity = guild_identity
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -90,12 +85,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":
@@ -108,14 +107,14 @@ class GuildRequestServerPacket(Packet):
         Returns:
             GuildRequestServerPacket: The data to serialize.
         """
-        data: GuildRequestServerPacket = GuildRequestServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._player_id = reader.get_short()
-            data._guild_identity = reader.get_string()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            player_id = reader.get_short()
+            guild_identity = reader.get_string()
+            result = GuildRequestServerPacket(player_id=player_id, guild_identity=guild_identity)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -15,7 +15,16 @@ class GuildSellServerPacket(Packet):
     Get guild bank reply
     """
     _byte_size: int = 0
-    _gold_amount: int = None # type: ignore [assignment]
+    _gold_amount: int
+
+    def __init__(self, *, gold_amount: int):
+        """
+        Create a new instance of GuildSellServerPacket.
+
+        Args:
+            gold_amount (int): (Value range is 0-4097152080.)
+        """
+        self._gold_amount = gold_amount
 
     @property
     def byte_size(self) -> int:
@@ -29,20 +38,8 @@ class GuildSellServerPacket(Packet):
 
     @property
     def gold_amount(self) -> int:
-        """
-        Note:
-          - Value range is 0-4097152080.
-        """
         return self._gold_amount
 
-    @gold_amount.setter
-    def gold_amount(self, gold_amount: int) -> None:
-        """
-        Note:
-          - Value range is 0-4097152080.
-        """
-        self._gold_amount = gold_amount
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -81,9 +78,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":
@@ -96,13 +97,13 @@ class GuildSellServerPacket(Packet):
         Returns:
             GuildSellServerPacket: The data to serialize.
         """
-        data: GuildSellServerPacket = GuildSellServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._gold_amount = reader.get_int()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            gold_amount = reader.get_int()
+            result = GuildSellServerPacket(gold_amount=gold_amount)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -12,8 +12,19 @@ class GuildStaff:
     Information about a guild staff member (recruiter or leader)
     """
     _byte_size: int = 0
-    _rank: int = None # type: ignore [assignment]
-    _name: str = None # type: ignore [assignment]
+    _rank: int
+    _name: str
+
+    def __init__(self, *, rank: int, name: str):
+        """
+        Create a new instance of GuildStaff.
+
+        Args:
+            rank (int): (Value range is 0-252.)
+            name (str): 
+        """
+        self._rank = rank
+        self._name = name
 
     @property
     def byte_size(self) -> int:
@@ -27,28 +38,12 @@ class GuildStaff:
 
     @property
     def rank(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._rank
 
-    @rank.setter
-    def rank(self, rank: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._rank = rank
-
     @property
     def name(self) -> str:
         return self._name
 
-    @name.setter
-    def name(self, name: str) -> None:
-        self._name = name
-
     @staticmethod
     def serialize(writer: EoWriter, data: "GuildStaff") -> None:
         """
@@ -58,13 +53,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":
@@ -77,17 +78,17 @@ class GuildStaff:
         Returns:
             GuildStaff: The data to serialize.
         """
-        data: GuildStaff = GuildStaff()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
-            data._rank = reader.get_char()
+            rank = reader.get_char()
             reader.next_chunk()
-            data._name = reader.get_string()
+            name = reader.get_string()
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = GuildStaff(rank=rank, name=name)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -15,7 +15,16 @@ class GuildTakeServerPacket(Packet):
     Get guild description reply
     """
     _byte_size: int = 0
-    _description: str = None # type: ignore [assignment]
+    _description: str
+
+    def __init__(self, *, description: str):
+        """
+        Create a new instance of GuildTakeServerPacket.
+
+        Args:
+            description (str): 
+        """
+        self._description = description
 
     @property
     def byte_size(self) -> int:
@@ -31,10 +40,6 @@ class GuildTakeServerPacket(Packet):
     def description(self) -> str:
         return self._description
 
-    @description.setter
-    def description(self, description: str) -> None:
-        self._description = description
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -73,9 +78,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":
@@ -88,13 +97,13 @@ class GuildTakeServerPacket(Packet):
         Returns:
             GuildTakeServerPacket: The data to serialize.
         """
-        data: GuildTakeServerPacket = GuildTakeServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._description = reader.get_string()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            description = reader.get_string()
+            result = GuildTakeServerPacket(description=description)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode