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

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

@@ -15,7 +15,16 @@ class MarriageOpenServerPacket(Packet):
     Response from talking to a law NPC
     """
     _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 MarriageOpenServerPacket.
+
+        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 MarriageOpenServerPacket(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 MarriageOpenServerPacket(Packet):
         Returns:
             MarriageOpenServerPacket: The data to serialize.
         """
-        data: MarriageOpenServerPacket = MarriageOpenServerPacket()
         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 = MarriageOpenServerPacket(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/marriage_reply_server_packet.py

@@ -17,8 +17,19 @@ class MarriageReplyServerPacket(Packet):
     Reply to client Marriage-family packets
     """
     _byte_size: int = 0
-    _reply_code: MarriageReply = None # type: ignore [assignment]
-    _reply_code_data: 'MarriageReplyServerPacket.ReplyCodeData' = None
+    _reply_code: MarriageReply
+    _reply_code_data: 'MarriageReplyServerPacket.ReplyCodeData'
+
+    def __init__(self, *, reply_code: MarriageReply, reply_code_data: 'MarriageReplyServerPacket.ReplyCodeData' = None):
+        """
+        Create a new instance of MarriageReplyServerPacket.
+
+        Args:
+            reply_code (MarriageReply): 
+            reply_code_data (MarriageReplyServerPacket.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 MarriageReplyServerPacket(Packet):
     def reply_code(self) -> MarriageReply:
         return self._reply_code
 
-    @reply_code.setter
-    def reply_code(self, reply_code: MarriageReply) -> None:
-        self._reply_code = reply_code
-
     @property
     def reply_code_data(self) -> 'MarriageReplyServerPacket.ReplyCodeData':
         """
-        MarriageReplyServerPacket.ReplyCodeData: Gets or sets the data associated with the `reply_code` field.
+        MarriageReplyServerPacket.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: 'MarriageReplyServerPacket.ReplyCodeData') -> None:
-        self._reply_code_data = reply_code_data
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -110,15 +113,16 @@ class MarriageReplyServerPacket(Packet):
         Returns:
             MarriageReplyServerPacket: The data to serialize.
         """
-        data: MarriageReplyServerPacket = MarriageReplyServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._reply_code = MarriageReply(reader.get_short())
-            if data._reply_code == MarriageReply.Success:
-                data._reply_code_data = MarriageReplyServerPacket.ReplyCodeDataSuccess.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            reply_code = MarriageReply(reader.get_short())
+            reply_code_data: MarriageReplyServerPacket.ReplyCodeData = None
+            if reply_code == MarriageReply.Success:
+                reply_code_data = MarriageReplyServerPacket.ReplyCodeDataSuccess.deserialize(reader)
+            result = MarriageReplyServerPacket(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
 
@@ -135,7 +139,16 @@ class MarriageReplyServerPacket(Packet):
         Data associated with reply_code value MarriageReply.Success
         """
         _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 MarriageReplyServerPacket.ReplyCodeDataSuccess.
+
+            Args:
+                gold_amount (int): (Value range is 0-4097152080.)
+            """
+            self._gold_amount = gold_amount
 
         @property
         def byte_size(self) -> int:
@@ -149,20 +162,8 @@ class MarriageReplyServerPacket(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 serialize(writer: EoWriter, data: "MarriageReplyServerPacket.ReplyCodeDataSuccess") -> None:
             """
@@ -191,13 +192,13 @@ class MarriageReplyServerPacket(Packet):
             Returns:
                 MarriageReplyServerPacket.ReplyCodeDataSuccess: The data to serialize.
             """
-            data: MarriageReplyServerPacket.ReplyCodeDataSuccess = MarriageReplyServerPacket.ReplyCodeDataSuccess()
             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 = MarriageReplyServerPacket.ReplyCodeDataSuccess(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/message_accept_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 MessageAcceptServerPacket(Packet):
     Large message box
     """
     _byte_size: int = 0
-    _messages: list[str] = None # type: ignore [assignment]
+    _messages: tuple[str, ...]
+
+    def __init__(self, *, messages: Iterable[str]):
+        """
+        Create a new instance of MessageAcceptServerPacket.
+
+        Args:
+            messages (Iterable[str]): (Length must be `4`.)
+        """
+        self._messages = tuple(messages)
 
     @property
     def byte_size(self) -> int:
@@ -29,21 +39,9 @@ class MessageAcceptServerPacket(Packet):
         return self._byte_size
 
     @property
-    def messages(self) -> list[str]:
-        """
-        Note:
-          - Length must be `4`.
-        """
+    def messages(self) -> tuple[str, ...]:
         return self._messages
 
-    @messages.setter
-    def messages(self, messages: list[str]) -> None:
-        """
-        Note:
-          - Length must be `4`.
-        """
-        self._messages = messages
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -107,18 +105,18 @@ class MessageAcceptServerPacket(Packet):
         Returns:
             MessageAcceptServerPacket: The data to serialize.
         """
-        data: MessageAcceptServerPacket = MessageAcceptServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
-            data._messages = []
+            messages = []
             for i in range(4):
-                data._messages.append(reader.get_string())
+                messages.append(reader.get_string())
                 reader.next_chunk()
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = MessageAcceptServerPacket(messages=messages)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -15,6 +15,11 @@ class MessageCloseServerPacket(Packet):
     """
     _byte_size: int = 0
 
+    def __init__(self):
+        """
+        Create a new instance of MessageCloseServerPacket.
+        """
+
     @property
     def byte_size(self) -> int:
         """
@@ -80,13 +85,13 @@ class MessageCloseServerPacket(Packet):
         Returns:
             MessageCloseServerPacket: The data to serialize.
         """
-        data: MessageCloseServerPacket = MessageCloseServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.get_string()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = MessageCloseServerPacket()
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -15,7 +15,16 @@ class MessageOpenServerPacket(Packet):
     Status bar message
     """
     _byte_size: int = 0
-    _message: str = None # type: ignore [assignment]
+    _message: str
+
+    def __init__(self, *, message: str):
+        """
+        Create a new instance of MessageOpenServerPacket.
+
+        Args:
+            message (str): 
+        """
+        self._message = message
 
     @property
     def byte_size(self) -> int:
@@ -31,10 +40,6 @@ class MessageOpenServerPacket(Packet):
     def message(self) -> str:
         return self._message
 
-    @message.setter
-    def message(self, message: str) -> None:
-        self._message = message
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -92,13 +97,13 @@ class MessageOpenServerPacket(Packet):
         Returns:
             MessageOpenServerPacket: The data to serialize.
         """
-        data: MessageOpenServerPacket = MessageOpenServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._message = reader.get_string()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            message = reader.get_string()
+            result = MessageOpenServerPacket(message=message)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -15,6 +15,11 @@ class MessagePongServerPacket(Packet):
     """
     _byte_size: int = 0
 
+    def __init__(self):
+        """
+        Create a new instance of MessagePongServerPacket.
+        """
+
     @property
     def byte_size(self) -> int:
         """
@@ -80,13 +85,13 @@ class MessagePongServerPacket(Packet):
         Returns:
             MessagePongServerPacket: The data to serialize.
         """
-        data: MessagePongServerPacket = MessagePongServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.get_short()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = MessagePongServerPacket()
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -15,7 +15,16 @@ class MusicPlayerServerPacket(Packet):
     Sound effect
     """
     _byte_size: int = 0
-    _sound_id: int = None # type: ignore [assignment]
+    _sound_id: int
+
+    def __init__(self, *, sound_id: int):
+        """
+        Create a new instance of MusicPlayerServerPacket.
+
+        Args:
+            sound_id (int): (Value range is 0-252.)
+        """
+        self._sound_id = sound_id
 
     @property
     def byte_size(self) -> int:
@@ -29,20 +38,8 @@ class MusicPlayerServerPacket(Packet):
 
     @property
     def sound_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._sound_id
 
-    @sound_id.setter
-    def sound_id(self, sound_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._sound_id = sound_id
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -100,13 +97,13 @@ class MusicPlayerServerPacket(Packet):
         Returns:
             MusicPlayerServerPacket: The data to serialize.
         """
-        data: MusicPlayerServerPacket = MusicPlayerServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._sound_id = reader.get_char()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            sound_id = reader.get_char()
+            result = MusicPlayerServerPacket(sound_id=sound_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/nearby_info.py

@@ -4,6 +4,7 @@
 # Changes will be lost when code is regenerated.
 
 from __future__ import annotations
+from collections.abc import Iterable
 from .npc_map_info import NpcMapInfo
 from .item_map_info import ItemMapInfo
 from .character_map_info import CharacterMapInfo
@@ -16,10 +17,24 @@ class NearbyInfo:
     Information about nearby entities
     """
     _byte_size: int = 0
-    _characters_count: int = None # type: ignore [assignment]
-    _characters: list[CharacterMapInfo] = None # type: ignore [assignment]
-    _npcs: list[NpcMapInfo] = None # type: ignore [assignment]
-    _items: list[ItemMapInfo] = None # type: ignore [assignment]
+    _characters_count: int
+    _characters: tuple[CharacterMapInfo, ...]
+    _npcs: tuple[NpcMapInfo, ...]
+    _items: tuple[ItemMapInfo, ...]
+
+    def __init__(self, *, characters: Iterable[CharacterMapInfo], npcs: Iterable[NpcMapInfo], items: Iterable[ItemMapInfo]):
+        """
+        Create a new instance of NearbyInfo.
+
+        Args:
+            characters (Iterable[CharacterMapInfo]): (Length must be 252 or less.)
+            npcs (Iterable[NpcMapInfo]): 
+            items (Iterable[ItemMapInfo]): 
+        """
+        self._characters = tuple(characters)
+        self._characters_count = len(self._characters)
+        self._npcs = tuple(npcs)
+        self._items = tuple(items)
 
     @property
     def byte_size(self) -> int:
@@ -32,38 +47,17 @@ class NearbyInfo:
         return self._byte_size
 
     @property
-    def characters(self) -> list[CharacterMapInfo]:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
+    def characters(self) -> tuple[CharacterMapInfo, ...]:
         return self._characters
 
-    @characters.setter
-    def characters(self, characters: list[CharacterMapInfo]) -> None:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
-        self._characters = characters
-        self._characters_count = len(self._characters)
-
     @property
-    def npcs(self) -> list[NpcMapInfo]:
+    def npcs(self) -> tuple[NpcMapInfo, ...]:
         return self._npcs
 
-    @npcs.setter
-    def npcs(self, npcs: list[NpcMapInfo]) -> None:
-        self._npcs = npcs
-
     @property
-    def items(self) -> list[ItemMapInfo]:
+    def items(self) -> tuple[ItemMapInfo, ...]:
         return self._items
 
-    @items.setter
-    def items(self, items: list[ItemMapInfo]) -> None:
-        self._items = items
-
     @staticmethod
     def serialize(writer: EoWriter, data: "NearbyInfo") -> None:
         """
@@ -111,29 +105,29 @@ class NearbyInfo:
         Returns:
             NearbyInfo: The data to serialize.
         """
-        data: NearbyInfo = NearbyInfo()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._characters_count = reader.get_char()
+            characters_count = reader.get_char()
             reader.chunked_reading_mode = True
             reader.next_chunk()
-            data._characters = []
-            for i in range(data._characters_count):
-                data._characters.append(CharacterMapInfo.deserialize(reader))
+            characters = []
+            for i in range(characters_count):
+                characters.append(CharacterMapInfo.deserialize(reader))
                 reader.next_chunk()
             npcs_length = int(reader.remaining / 6)
-            data._npcs = []
+            npcs = []
             for i in range(npcs_length):
-                data._npcs.append(NpcMapInfo.deserialize(reader))
+                npcs.append(NpcMapInfo.deserialize(reader))
             reader.next_chunk()
             items_length = int(reader.remaining / 9)
-            data._items = []
+            items = []
             for i in range(items_length):
-                data._items.append(ItemMapInfo.deserialize(reader))
+                items.append(ItemMapInfo.deserialize(reader))
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = NearbyInfo(characters=characters, npcs=npcs, items=items)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -3,6 +3,8 @@
 # This file should not be modified.
 # Changes will be lost when code is regenerated.
 
+from typing import cast
+from typing import Optional
 from .npc_killed_data import NpcKilledData
 from .level_up_stats import LevelUpStats
 from ..packet_family import PacketFamily
@@ -14,12 +16,25 @@ from .....data.eo_reader import EoReader
 
 class NpcAcceptServerPacket(Packet):
     """
-    Nearby NPC killed by player and you leveled up
+    Nearby NPC killed and killer leveled up
     """
     _byte_size: int = 0
-    _npc_killed_data: NpcKilledData = None # type: ignore [assignment]
-    _experience: int = None # type: ignore [assignment]
-    _level_up: LevelUpStats = None # type: ignore [assignment]
+    _npc_killed_data: NpcKilledData
+    _experience: Optional[int]
+    _level_up: Optional[LevelUpStats]
+
+    def __init__(self, *, npc_killed_data: NpcKilledData, experience: Optional[int] = None, level_up: Optional[LevelUpStats] = None):
+        """
+        Create a new instance of NpcAcceptServerPacket.
+
+        Args:
+            npc_killed_data (NpcKilledData): 
+            experience (Optional[int]): This field should be sent to the killer, but not nearby players (Value range is 0-4097152080.)
+            level_up (Optional[LevelUpStats]): This field should be sent to the killer if they leveled up, but not nearby players
+        """
+        self._npc_killed_data = npc_killed_data
+        self._experience = experience
+        self._level_up = level_up
 
     @property
     def byte_size(self) -> int:
@@ -35,34 +50,20 @@ class NpcAcceptServerPacket(Packet):
     def npc_killed_data(self) -> NpcKilledData:
         return self._npc_killed_data
 
-    @npc_killed_data.setter
-    def npc_killed_data(self, npc_killed_data: NpcKilledData) -> None:
-        self._npc_killed_data = npc_killed_data
-
     @property
-    def experience(self) -> int:
+    def experience(self) -> Optional[int]:
         """
-        Note:
-          - Value range is 0-4097152080.
+        This field should be sent to the killer, but not nearby players
         """
         return self._experience
 
-    @experience.setter
-    def experience(self, experience: int) -> None:
+    @property
+    def level_up(self) -> Optional[LevelUpStats]:
         """
-        Note:
-          - Value range is 0-4097152080.
+        This field should be sent to the killer if they leveled up, but not nearby players
         """
-        self._experience = experience
-
-    @property
-    def level_up(self) -> LevelUpStats:
         return self._level_up
 
-    @level_up.setter
-    def level_up(self, level_up: LevelUpStats) -> None:
-        self._level_up = level_up
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -106,12 +107,12 @@ class NpcAcceptServerPacket(Packet):
             if data._npc_killed_data is None:
                 raise SerializationError("npc_killed_data must be provided.")
             NpcKilledData.serialize(writer, data._npc_killed_data)
-            if data._experience is None:
-                raise SerializationError("experience must be provided.")
-            writer.add_int(data._experience)
-            if data._level_up is None:
-                raise SerializationError("level_up must be provided.")
-            LevelUpStats.serialize(writer, data._level_up)
+            reached_missing_optional = data._experience is None
+            if not reached_missing_optional:
+                writer.add_int(cast(int, data._experience))
+            reached_missing_optional = reached_missing_optional or data._level_up is None
+            if not reached_missing_optional:
+                LevelUpStats.serialize(writer, cast(LevelUpStats, data._level_up))
         finally:
             writer.string_sanitization_mode = old_string_sanitization_mode
 
@@ -126,15 +127,19 @@ class NpcAcceptServerPacket(Packet):
         Returns:
             NpcAcceptServerPacket: The data to serialize.
         """
-        data: NpcAcceptServerPacket = NpcAcceptServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._npc_killed_data = NpcKilledData.deserialize(reader)
-            data._experience = reader.get_int()
-            data._level_up = LevelUpStats.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            npc_killed_data = NpcKilledData.deserialize(reader)
+            experience: Optional[int] = None
+            if reader.remaining > 0:
+                experience = reader.get_int()
+            level_up: Optional[LevelUpStats] = None
+            if reader.remaining > 0:
+                level_up = LevelUpStats.deserialize(reader)
+            result = NpcAcceptServerPacket(npc_killed_data=npc_killed_data, experience=experience, level_up=level_up)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode