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

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

@@ -12,9 +12,22 @@ class GuildMember:
     Information about a guild member
     """
     _byte_size: int = 0
-    _rank: int = None # type: ignore [assignment]
-    _name: str = None # type: ignore [assignment]
-    _rank_name: str = None # type: ignore [assignment]
+    _rank: int
+    _name: str
+    _rank_name: str
+
+    def __init__(self, *, rank: int, name: str, rank_name: str):
+        """
+        Create a new instance of GuildMember.
+
+        Args:
+            rank (int): (Value range is 0-252.)
+            name (str): 
+            rank_name (str): 
+        """
+        self._rank = rank
+        self._name = name
+        self._rank_name = rank_name
 
     @property
     def byte_size(self) -> int:
@@ -28,36 +41,16 @@ class GuildMember:
 
     @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
-
     @property
     def rank_name(self) -> str:
         return self._rank_name
 
-    @rank_name.setter
-    def rank_name(self, rank_name: str) -> None:
-        self._rank_name = rank_name
-
     @staticmethod
     def serialize(writer: EoWriter, data: "GuildMember") -> None:
         """
@@ -96,19 +89,19 @@ class GuildMember:
         Returns:
             GuildMember: The data to serialize.
         """
-        data: GuildMember = GuildMember()
         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.next_chunk()
-            data._rank_name = reader.get_string()
+            rank_name = reader.get_string()
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = GuildMember(rank=rank, name=name, rank_name=rank_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_open_server_packet.py

@@ -15,7 +15,16 @@ class GuildOpenServerPacket(Packet):
     Talk to guild master NPC reply
     """
     _byte_size: int = 0
-    _session_id: int = None # type: ignore [assignment]
+    _session_id: int
+
+    def __init__(self, *, session_id: int):
+        """
+        Create a new instance of GuildOpenServerPacket.
+
+        Args:
+            session_id (int): (Value range is 0-16194276.)
+        """
+        self._session_id = session_id
 
     @property
     def byte_size(self) -> int:
@@ -29,20 +38,8 @@ class GuildOpenServerPacket(Packet):
 
     @property
     def session_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-16194276.
-        """
         return self._session_id
 
-    @session_id.setter
-    def session_id(self, session_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-16194276.
-        """
-        self._session_id = session_id
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -100,13 +97,13 @@ class GuildOpenServerPacket(Packet):
         Returns:
             GuildOpenServerPacket: The data to serialize.
         """
-        data: GuildOpenServerPacket = GuildOpenServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._session_id = reader.get_three()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            session_id = reader.get_three()
+            result = GuildOpenServerPacket(session_id=session_id)
+            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_rank_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 ..packet_family import PacketFamily
 from ..packet_action import PacketAction
 from ....serialization_error import SerializationError
@@ -16,7 +17,16 @@ class GuildRankServerPacket(Packet):
     Get guild rank list reply
     """
     _byte_size: int = 0
-    _ranks: list[str] = None # type: ignore [assignment]
+    _ranks: tuple[str, ...]
+
+    def __init__(self, *, ranks: Iterable[str]):
+        """
+        Create a new instance of GuildRankServerPacket.
+
+        Args:
+            ranks (Iterable[str]): (Length must be `9`.)
+        """
+        self._ranks = tuple(ranks)
 
     @property
     def byte_size(self) -> int:
@@ -29,21 +39,9 @@ class GuildRankServerPacket(Packet):
         return self._byte_size
 
     @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
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -107,18 +105,18 @@ class GuildRankServerPacket(Packet):
         Returns:
             GuildRankServerPacket: The data to serialize.
         """
-        data: GuildRankServerPacket = GuildRankServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
-            data._ranks = []
+            ranks = []
             for i in range(9):
-                data._ranks.append(reader.get_string())
+                ranks.append(reader.get_string())
                 reader.next_chunk()
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = GuildRankServerPacket(ranks=ranks)
+            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_reply_server_packet.py

@@ -17,8 +17,19 @@ class GuildReplyServerPacket(Packet):
     Generic guild reply messages
     """
     _byte_size: int = 0
-    _reply_code: GuildReply = None # type: ignore [assignment]
-    _reply_code_data: 'GuildReplyServerPacket.ReplyCodeData' = None
+    _reply_code: GuildReply
+    _reply_code_data: 'GuildReplyServerPacket.ReplyCodeData'
+
+    def __init__(self, *, reply_code: GuildReply, reply_code_data: 'GuildReplyServerPacket.ReplyCodeData' = None):
+        """
+        Create a new instance of GuildReplyServerPacket.
+
+        Args:
+            reply_code (GuildReply): 
+            reply_code_data (GuildReplyServerPacket.ReplyCodeData): Data associated with the `reply_code` field.
+        """
+        self._reply_code = reply_code
+        self._reply_code_data = reply_code_data
 
     @property
     def byte_size(self) -> int:
@@ -34,21 +45,13 @@ class GuildReplyServerPacket(Packet):
     def reply_code(self) -> GuildReply:
         return self._reply_code
 
-    @reply_code.setter
-    def reply_code(self, reply_code: GuildReply) -> None:
-        self._reply_code = reply_code
-
     @property
     def reply_code_data(self) -> 'GuildReplyServerPacket.ReplyCodeData':
         """
-        GuildReplyServerPacket.ReplyCodeData: Gets or sets the data associated with the `reply_code` field.
+        GuildReplyServerPacket.ReplyCodeData: Data associated with the `reply_code` field.
         """
         return self._reply_code_data
 
-    @reply_code_data.setter
-    def reply_code_data(self, reply_code_data: 'GuildReplyServerPacket.ReplyCodeData') -> None:
-        self._reply_code_data = reply_code_data
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -118,19 +121,20 @@ class GuildReplyServerPacket(Packet):
         Returns:
             GuildReplyServerPacket: The data to serialize.
         """
-        data: GuildReplyServerPacket = GuildReplyServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._reply_code = GuildReply(reader.get_short())
-            if data._reply_code == GuildReply.CreateAdd:
-                data._reply_code_data = GuildReplyServerPacket.ReplyCodeDataCreateAdd.deserialize(reader)
-            elif data._reply_code == GuildReply.CreateAddConfirm:
-                data._reply_code_data = GuildReplyServerPacket.ReplyCodeDataCreateAddConfirm.deserialize(reader)
-            elif data._reply_code == GuildReply.JoinRequest:
-                data._reply_code_data = GuildReplyServerPacket.ReplyCodeDataJoinRequest.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            reply_code = GuildReply(reader.get_short())
+            reply_code_data: GuildReplyServerPacket.ReplyCodeData = None
+            if reply_code == GuildReply.CreateAdd:
+                reply_code_data = GuildReplyServerPacket.ReplyCodeDataCreateAdd.deserialize(reader)
+            elif reply_code == GuildReply.CreateAddConfirm:
+                reply_code_data = GuildReplyServerPacket.ReplyCodeDataCreateAddConfirm.deserialize(reader)
+            elif reply_code == GuildReply.JoinRequest:
+                reply_code_data = GuildReplyServerPacket.ReplyCodeDataJoinRequest.deserialize(reader)
+            result = GuildReplyServerPacket(reply_code=reply_code, reply_code_data=reply_code_data)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -147,7 +151,16 @@ class GuildReplyServerPacket(Packet):
         Data associated with reply_code value GuildReply.CreateAdd
         """
         _byte_size: int = 0
-        _name: str = None # type: ignore [assignment]
+        _name: str
+
+        def __init__(self, *, name: str):
+            """
+            Create a new instance of GuildReplyServerPacket.ReplyCodeDataCreateAdd.
+
+            Args:
+                name (str): 
+            """
+            self._name = name
 
         @property
         def byte_size(self) -> int:
@@ -163,10 +176,6 @@ class GuildReplyServerPacket(Packet):
         def name(self) -> str:
             return self._name
 
-        @name.setter
-        def name(self, name: str) -> None:
-            self._name = name
-
         @staticmethod
         def serialize(writer: EoWriter, data: "GuildReplyServerPacket.ReplyCodeDataCreateAdd") -> None:
             """
@@ -195,13 +204,13 @@ class GuildReplyServerPacket(Packet):
             Returns:
                 GuildReplyServerPacket.ReplyCodeDataCreateAdd: The data to serialize.
             """
-            data: GuildReplyServerPacket.ReplyCodeDataCreateAdd = GuildReplyServerPacket.ReplyCodeDataCreateAdd()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._name = reader.get_string()
-                data._byte_size = reader.position - reader_start_position
-                return data
+                name = reader.get_string()
+                result = GuildReplyServerPacket.ReplyCodeDataCreateAdd(name=name)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -213,7 +222,16 @@ class GuildReplyServerPacket(Packet):
         Data associated with reply_code value GuildReply.CreateAddConfirm
         """
         _byte_size: int = 0
-        _name: str = None # type: ignore [assignment]
+        _name: str
+
+        def __init__(self, *, name: str):
+            """
+            Create a new instance of GuildReplyServerPacket.ReplyCodeDataCreateAddConfirm.
+
+            Args:
+                name (str): 
+            """
+            self._name = name
 
         @property
         def byte_size(self) -> int:
@@ -229,10 +247,6 @@ class GuildReplyServerPacket(Packet):
         def name(self) -> str:
             return self._name
 
-        @name.setter
-        def name(self, name: str) -> None:
-            self._name = name
-
         @staticmethod
         def serialize(writer: EoWriter, data: "GuildReplyServerPacket.ReplyCodeDataCreateAddConfirm") -> None:
             """
@@ -261,13 +275,13 @@ class GuildReplyServerPacket(Packet):
             Returns:
                 GuildReplyServerPacket.ReplyCodeDataCreateAddConfirm: The data to serialize.
             """
-            data: GuildReplyServerPacket.ReplyCodeDataCreateAddConfirm = GuildReplyServerPacket.ReplyCodeDataCreateAddConfirm()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._name = reader.get_string()
-                data._byte_size = reader.position - reader_start_position
-                return data
+                name = reader.get_string()
+                result = GuildReplyServerPacket.ReplyCodeDataCreateAddConfirm(name=name)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -279,8 +293,19 @@ class GuildReplyServerPacket(Packet):
         Data associated with reply_code value GuildReply.JoinRequest
         """
         _byte_size: int = 0
-        _player_id: int = None # type: ignore [assignment]
-        _name: str = None # type: ignore [assignment]
+        _player_id: int
+        _name: str
+
+        def __init__(self, *, player_id: int, name: str):
+            """
+            Create a new instance of GuildReplyServerPacket.ReplyCodeDataJoinRequest.
+
+            Args:
+                player_id (int): (Value range is 0-64008.)
+                name (str): 
+            """
+            self._player_id = player_id
+            self._name = name
 
         @property
         def byte_size(self) -> int:
@@ -294,28 +319,12 @@ class GuildReplyServerPacket(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 name(self) -> str:
             return self._name
 
-        @name.setter
-        def name(self, name: str) -> None:
-            self._name = name
-
         @staticmethod
         def serialize(writer: EoWriter, data: "GuildReplyServerPacket.ReplyCodeDataJoinRequest") -> None:
             """
@@ -347,14 +356,14 @@ class GuildReplyServerPacket(Packet):
             Returns:
                 GuildReplyServerPacket.ReplyCodeDataJoinRequest: The data to serialize.
             """
-            data: GuildReplyServerPacket.ReplyCodeDataJoinRequest = GuildReplyServerPacket.ReplyCodeDataJoinRequest()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._player_id = reader.get_short()
-                data._name = reader.get_string()
-                data._byte_size = reader.position - reader_start_position
-                return data
+                player_id = reader.get_short()
+                name = reader.get_string()
+                result = GuildReplyServerPacket.ReplyCodeDataJoinRequest(player_id=player_id, 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_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:
         """
@@ -203,34 +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())
+                ranks.append(reader.get_string())
                 reader.next_chunk()
-            data._staff_count = reader.get_short()
+            staff_count = reader.get_short()
             reader.next_chunk()
-            data._staff = []
-            for i in range(data._staff_count):
-                data._staff.append(GuildStaff.deserialize(reader))
+            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