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

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

@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 from typing import Union
+from collections.abc import Iterable
 from .quest_progress_entry import QuestProgressEntry
 from ..quest_page import QuestPage
 from ..packet_family import PacketFamily
@@ -19,9 +20,22 @@ class QuestListServerPacket(Packet):
     Quest history / progress reply
     """
     _byte_size: int = 0
-    _page: QuestPage = None # type: ignore [assignment]
-    _quests_count: int = None # type: ignore [assignment]
-    _page_data: 'QuestListServerPacket.PageData' = None
+    _page: QuestPage
+    _quests_count: int
+    _page_data: 'QuestListServerPacket.PageData'
+
+    def __init__(self, *, page: QuestPage, quests_count: int, page_data: 'QuestListServerPacket.PageData' = None):
+        """
+        Create a new instance of QuestListServerPacket.
+
+        Args:
+            page (QuestPage): 
+            quests_count (int): (Value range is 0-64008.)
+            page_data (QuestListServerPacket.PageData): Data associated with the `page` field.
+        """
+        self._page = page
+        self._quests_count = quests_count
+        self._page_data = page_data
 
     @property
     def byte_size(self) -> int:
@@ -37,37 +51,17 @@ class QuestListServerPacket(Packet):
     def page(self) -> QuestPage:
         return self._page
 
-    @page.setter
-    def page(self, page: QuestPage) -> None:
-        self._page = page
-
     @property
     def quests_count(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._quests_count
 
-    @quests_count.setter
-    def quests_count(self, quests_count: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._quests_count = quests_count
-
     @property
     def page_data(self) -> 'QuestListServerPacket.PageData':
         """
-        QuestListServerPacket.PageData: Gets or sets the data associated with the `page` field.
+        QuestListServerPacket.PageData: Data associated with the `page` field.
         """
         return self._page_data
 
-    @page_data.setter
-    def page_data(self, page_data: 'QuestListServerPacket.PageData') -> None:
-        self._page_data = page_data
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -106,20 +100,26 @@ class QuestListServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (QuestListServerPacket): The data to serialize.
         """
-        if data._page is None:
-            raise SerializationError("page must be provided.")
-        writer.add_char(int(data._page))
-        if data._quests_count is None:
-            raise SerializationError("quests_count must be provided.")
-        writer.add_short(data._quests_count)
-        if data._page == QuestPage.Progress:
-            if not isinstance(data._page_data, QuestListServerPacket.PageDataProgress):
-                raise SerializationError("Expected page_data to be type QuestListServerPacket.PageDataProgress for page " + QuestPage(data._page).name + ".")
-            QuestListServerPacket.PageDataProgress.serialize(writer, data._page_data)
-        elif data._page == QuestPage.History:
-            if not isinstance(data._page_data, QuestListServerPacket.PageDataHistory):
-                raise SerializationError("Expected page_data to be type QuestListServerPacket.PageDataHistory for page " + QuestPage(data._page).name + ".")
-            QuestListServerPacket.PageDataHistory.serialize(writer, data._page_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._page is None:
+                raise SerializationError("page must be provided.")
+            writer.add_char(int(data._page))
+            if data._quests_count is None:
+                raise SerializationError("quests_count must be provided.")
+            writer.add_short(data._quests_count)
+            if data._page == QuestPage.Progress:
+                if not isinstance(data._page_data, QuestListServerPacket.PageDataProgress):
+                    raise SerializationError("Expected page_data to be type QuestListServerPacket.PageDataProgress for page " + QuestPage(data._page).name + ".")
+                QuestListServerPacket.PageDataProgress.serialize(writer, data._page_data)
+            elif data._page == QuestPage.History:
+                if not isinstance(data._page_data, QuestListServerPacket.PageDataHistory):
+                    raise SerializationError("Expected page_data to be type QuestListServerPacket.PageDataHistory for page " + QuestPage(data._page).name + ".")
+                QuestListServerPacket.PageDataHistory.serialize(writer, data._page_data)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "QuestListServerPacket":
@@ -132,20 +132,21 @@ class QuestListServerPacket(Packet):
         Returns:
             QuestListServerPacket: The data to serialize.
         """
-        data: QuestListServerPacket = QuestListServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
-            data._page = QuestPage(reader.get_char())
-            data._quests_count = reader.get_short()
-            if data._page == QuestPage.Progress:
-                data._page_data = QuestListServerPacket.PageDataProgress.deserialize(reader)
-            elif data._page == QuestPage.History:
-                data._page_data = QuestListServerPacket.PageDataHistory.deserialize(reader)
+            page = QuestPage(reader.get_char())
+            quests_count = reader.get_short()
+            page_data: QuestListServerPacket.PageData = None
+            if page == QuestPage.Progress:
+                page_data = QuestListServerPacket.PageDataProgress.deserialize(reader)
+            elif page == QuestPage.History:
+                page_data = QuestListServerPacket.PageDataHistory.deserialize(reader)
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = QuestListServerPacket(page=page, quests_count=quests_count, page_data=page_data)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -153,17 +154,25 @@ class QuestListServerPacket(Packet):
         return f"QuestListServerPacket(byte_size={repr(self._byte_size)}, page={repr(self._page)}, quests_count={repr(self._quests_count)}, page_data={repr(self._page_data)})"
 
     PageData = Union['QuestListServerPacket.PageDataProgress', 'QuestListServerPacket.PageDataHistory', None]
-    PageData.__doc__ = \
-        """
-        Data associated with different values of the `page` field.
-        """
+    """
+    Data associated with different values of the `page` field.
+    """
 
     class PageDataProgress:
         """
         Data associated with page value QuestPage.Progress
         """
         _byte_size: int = 0
-        _quest_progress_entries: list[QuestProgressEntry] = None # type: ignore [assignment]
+        _quest_progress_entries: tuple[QuestProgressEntry, ...]
+
+        def __init__(self, *, quest_progress_entries: Iterable[QuestProgressEntry]):
+            """
+            Create a new instance of QuestListServerPacket.PageDataProgress.
+
+            Args:
+                quest_progress_entries (Iterable[QuestProgressEntry]): 
+            """
+            self._quest_progress_entries = tuple(quest_progress_entries)
 
         @property
         def byte_size(self) -> int:
@@ -176,13 +185,9 @@ class QuestListServerPacket(Packet):
             return self._byte_size
 
         @property
-        def quest_progress_entries(self) -> list[QuestProgressEntry]:
+        def quest_progress_entries(self) -> tuple[QuestProgressEntry, ...]:
             return self._quest_progress_entries
 
-        @quest_progress_entries.setter
-        def quest_progress_entries(self, quest_progress_entries: list[QuestProgressEntry]) -> None:
-            self._quest_progress_entries = quest_progress_entries
-
         @staticmethod
         def serialize(writer: EoWriter, data: "QuestListServerPacket.PageDataProgress") -> None:
             """
@@ -192,12 +197,15 @@ class QuestListServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (QuestListServerPacket.PageDataProgress): The data to serialize.
             """
-            if data._quest_progress_entries is None:
-                raise SerializationError("quest_progress_entries must be provided.")
-            for i in range(len(data._quest_progress_entries)):
-                if i > 0:
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._quest_progress_entries is None:
+                    raise SerializationError("quest_progress_entries must be provided.")
+                for i in range(len(data._quest_progress_entries)):
+                    QuestProgressEntry.serialize(writer, data._quest_progress_entries[i])
                     writer.add_byte(0xFF)
-                QuestProgressEntry.serialize(writer, data._quest_progress_entries[i])
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "QuestListServerPacket.PageDataProgress":
@@ -210,16 +218,16 @@ class QuestListServerPacket(Packet):
             Returns:
                 QuestListServerPacket.PageDataProgress: The data to serialize.
             """
-            data: QuestListServerPacket.PageDataProgress = QuestListServerPacket.PageDataProgress()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._quest_progress_entries = []
+                quest_progress_entries = []
                 while reader.remaining > 0:
-                    data._quest_progress_entries.append(QuestProgressEntry.deserialize(reader))
+                    quest_progress_entries.append(QuestProgressEntry.deserialize(reader))
                     reader.next_chunk()
-                data._byte_size = reader.position - reader_start_position
-                return data
+                result = QuestListServerPacket.PageDataProgress(quest_progress_entries=quest_progress_entries)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -231,7 +239,16 @@ class QuestListServerPacket(Packet):
         Data associated with page value QuestPage.History
         """
         _byte_size: int = 0
-        _completed_quests: list[str] = None # type: ignore [assignment]
+        _completed_quests: tuple[str, ...]
+
+        def __init__(self, *, completed_quests: Iterable[str]):
+            """
+            Create a new instance of QuestListServerPacket.PageDataHistory.
+
+            Args:
+                completed_quests (Iterable[str]): 
+            """
+            self._completed_quests = tuple(completed_quests)
 
         @property
         def byte_size(self) -> int:
@@ -244,13 +261,9 @@ class QuestListServerPacket(Packet):
             return self._byte_size
 
         @property
-        def completed_quests(self) -> list[str]:
+        def completed_quests(self) -> tuple[str, ...]:
             return self._completed_quests
 
-        @completed_quests.setter
-        def completed_quests(self, completed_quests: list[str]) -> None:
-            self._completed_quests = completed_quests
-
         @staticmethod
         def serialize(writer: EoWriter, data: "QuestListServerPacket.PageDataHistory") -> None:
             """
@@ -260,12 +273,15 @@ class QuestListServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (QuestListServerPacket.PageDataHistory): The data to serialize.
             """
-            if data._completed_quests is None:
-                raise SerializationError("completed_quests must be provided.")
-            for i in range(len(data._completed_quests)):
-                if i > 0:
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._completed_quests is None:
+                    raise SerializationError("completed_quests must be provided.")
+                for i in range(len(data._completed_quests)):
+                    writer.add_string(data._completed_quests[i])
                     writer.add_byte(0xFF)
-                writer.add_string(data._completed_quests[i])
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "QuestListServerPacket.PageDataHistory":
@@ -278,16 +294,16 @@ class QuestListServerPacket(Packet):
             Returns:
                 QuestListServerPacket.PageDataHistory: The data to serialize.
             """
-            data: QuestListServerPacket.PageDataHistory = QuestListServerPacket.PageDataHistory()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._completed_quests = []
+                completed_quests = []
                 while reader.remaining > 0:
-                    data._completed_quests.append(reader.get_string())
+                    completed_quests.append(reader.get_string())
                     reader.next_chunk()
-                data._byte_size = reader.position - reader_start_position
-                return data
+                result = QuestListServerPacket.PageDataHistory(completed_quests=completed_quests)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -13,11 +13,28 @@ class QuestProgressEntry:
     An entry in the Quest Progress window
     """
     _byte_size: int = 0
-    _name: str = None # type: ignore [assignment]
-    _description: str = None # type: ignore [assignment]
-    _icon: QuestRequirementIcon = None # type: ignore [assignment]
-    _progress: int = None # type: ignore [assignment]
-    _target: int = None # type: ignore [assignment]
+    _name: str
+    _description: str
+    _icon: QuestRequirementIcon
+    _progress: int
+    _target: int
+
+    def __init__(self, *, name: str, description: str, icon: QuestRequirementIcon, progress: int, target: int):
+        """
+        Create a new instance of QuestProgressEntry.
+
+        Args:
+            name (str): 
+            description (str): 
+            icon (QuestRequirementIcon): 
+            progress (int): (Value range is 0-64008.)
+            target (int): (Value range is 0-64008.)
+        """
+        self._name = name
+        self._description = description
+        self._icon = icon
+        self._progress = progress
+        self._target = target
 
     @property
     def byte_size(self) -> int:
@@ -33,58 +50,22 @@ class QuestProgressEntry:
     def name(self) -> str:
         return self._name
 
-    @name.setter
-    def name(self, name: str) -> None:
-        self._name = name
-
     @property
     def description(self) -> str:
         return self._description
 
-    @description.setter
-    def description(self, description: str) -> None:
-        self._description = description
-
     @property
     def icon(self) -> QuestRequirementIcon:
         return self._icon
 
-    @icon.setter
-    def icon(self, icon: QuestRequirementIcon) -> None:
-        self._icon = icon
-
     @property
     def progress(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._progress
 
-    @progress.setter
-    def progress(self, progress: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._progress = progress
-
     @property
     def target(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._target
 
-    @target.setter
-    def target(self, target: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._target = target
-
     @staticmethod
     def serialize(writer: EoWriter, data: "QuestProgressEntry") -> None:
         """
@@ -94,23 +75,29 @@ class QuestProgressEntry:
             writer (EoWriter): The writer that the data will be serialized to.
             data (QuestProgressEntry): 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._description is None:
-            raise SerializationError("description must be provided.")
-        writer.add_string(data._description)
-        writer.add_byte(0xFF)
-        if data._icon is None:
-            raise SerializationError("icon must be provided.")
-        writer.add_short(int(data._icon))
-        if data._progress is None:
-            raise SerializationError("progress must be provided.")
-        writer.add_short(data._progress)
-        if data._target is None:
-            raise SerializationError("target must be provided.")
-        writer.add_short(data._target)
+        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._description is None:
+                raise SerializationError("description must be provided.")
+            writer.add_string(data._description)
+            writer.add_byte(0xFF)
+            if data._icon is None:
+                raise SerializationError("icon must be provided.")
+            writer.add_short(int(data._icon))
+            if data._progress is None:
+                raise SerializationError("progress must be provided.")
+            writer.add_short(data._progress)
+            if data._target is None:
+                raise SerializationError("target must be provided.")
+            writer.add_short(data._target)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "QuestProgressEntry":
@@ -123,21 +110,21 @@ class QuestProgressEntry:
         Returns:
             QuestProgressEntry: The data to serialize.
         """
-        data: QuestProgressEntry = QuestProgressEntry()
         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._description = reader.get_string()
+            description = reader.get_string()
             reader.next_chunk()
-            data._icon = QuestRequirementIcon(reader.get_short())
-            data._progress = reader.get_short()
-            data._target = reader.get_short()
+            icon = QuestRequirementIcon(reader.get_short())
+            progress = reader.get_short()
+            target = reader.get_short()
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = QuestProgressEntry(name=name, description=description, icon=icon, progress=progress, target=target)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/net/server/quest_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 ..packet_family import PacketFamily
 from ..packet_action import PacketAction
 from ....serialization_error import SerializationError
@@ -16,8 +17,19 @@ class QuestReportServerPacket(Packet):
     NPC chat messages
     """
     _byte_size: int = 0
-    _npc_id: int = None # type: ignore [assignment]
-    _messages: list[str] = None # type: ignore [assignment]
+    _npc_index: int
+    _messages: tuple[str, ...]
+
+    def __init__(self, *, npc_index: int, messages: Iterable[str]):
+        """
+        Create a new instance of QuestReportServerPacket.
+
+        Args:
+            npc_index (int): (Value range is 0-64008.)
+            messages (Iterable[str]): 
+        """
+        self._npc_index = npc_index
+        self._messages = tuple(messages)
 
     @property
     def byte_size(self) -> int:
@@ -30,29 +42,13 @@ class QuestReportServerPacket(Packet):
         return self._byte_size
 
     @property
-    def npc_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        return self._npc_id
-
-    @npc_id.setter
-    def npc_id(self, npc_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._npc_id = npc_id
+    def npc_index(self) -> int:
+        return self._npc_index
 
     @property
-    def messages(self) -> list[str]:
+    def messages(self) -> tuple[str, ...]:
         return self._messages
 
-    @messages.setter
-    def messages(self, messages: list[str]) -> None:
-        self._messages = messages
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -91,16 +87,21 @@ class QuestReportServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (QuestReportServerPacket): The data to serialize.
         """
-        if data._npc_id is None:
-            raise SerializationError("npc_id must be provided.")
-        writer.add_short(data._npc_id)
-        writer.add_byte(0xFF)
-        if data._messages is None:
-            raise SerializationError("messages must be provided.")
-        for i in range(len(data._messages)):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._npc_index is None:
+                raise SerializationError("npc_index must be provided.")
+            writer.add_short(data._npc_index)
+            writer.add_byte(0xFF)
+            if data._messages is None:
+                raise SerializationError("messages must be provided.")
+            for i in range(len(data._messages)):
+                writer.add_string(data._messages[i])
                 writer.add_byte(0xFF)
-            writer.add_string(data._messages[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "QuestReportServerPacket":
@@ -113,22 +114,22 @@ class QuestReportServerPacket(Packet):
         Returns:
             QuestReportServerPacket: The data to serialize.
         """
-        data: QuestReportServerPacket = QuestReportServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
-            data._npc_id = reader.get_short()
+            npc_index = reader.get_short()
             reader.next_chunk()
-            data._messages = []
+            messages = []
             while reader.remaining > 0:
-                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 = QuestReportServerPacket(npc_index=npc_index, messages=messages)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 
     def __repr__(self):
-        return f"QuestReportServerPacket(byte_size={repr(self._byte_size)}, npc_id={repr(self._npc_id)}, messages={repr(self._messages)})"
+        return f"QuestReportServerPacket(byte_size={repr(self._byte_size)}, npc_index={repr(self._npc_index)}, messages={repr(self._messages)})"

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

@@ -16,7 +16,16 @@ class RangeReplyServerPacket(Packet):
     Reply to request for information about nearby players and NPCs
     """
     _byte_size: int = 0
-    _nearby: NearbyInfo = None # type: ignore [assignment]
+    _nearby: NearbyInfo
+
+    def __init__(self, *, nearby: NearbyInfo):
+        """
+        Create a new instance of RangeReplyServerPacket.
+
+        Args:
+            nearby (NearbyInfo): 
+        """
+        self._nearby = nearby
 
     @property
     def byte_size(self) -> int:
@@ -32,10 +41,6 @@ class RangeReplyServerPacket(Packet):
     def nearby(self) -> NearbyInfo:
         return self._nearby
 
-    @nearby.setter
-    def nearby(self, nearby: NearbyInfo) -> None:
-        self._nearby = nearby
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -74,9 +79,13 @@ class RangeReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (RangeReplyServerPacket): The data to serialize.
         """
-        if data._nearby is None:
-            raise SerializationError("nearby must be provided.")
-        NearbyInfo.serialize(writer, data._nearby)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._nearby is None:
+                raise SerializationError("nearby must be provided.")
+            NearbyInfo.serialize(writer, data._nearby)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "RangeReplyServerPacket":
@@ -89,13 +98,13 @@ class RangeReplyServerPacket(Packet):
         Returns:
             RangeReplyServerPacket: The data to serialize.
         """
-        data: RangeReplyServerPacket = RangeReplyServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._nearby = NearbyInfo.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            nearby = NearbyInfo.deserialize(reader)
+            result = RangeReplyServerPacket(nearby=nearby)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode