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

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

@@ -12,8 +12,19 @@ class PubFile:
     A pub file (EIF, ENF, ECF, ESF)
     """
     _byte_size: int = 0
-    _file_id: int = None # type: ignore [assignment]
-    _content: bytes = None # type: ignore [assignment]
+    _file_id: int
+    _content: bytes
+
+    def __init__(self, *, file_id: int, content: bytes):
+        """
+        Create a new instance of PubFile.
+
+        Args:
+            file_id (int): (Value range is 0-252.)
+            content (bytes): 
+        """
+        self._file_id = file_id
+        self._content = content
 
     @property
     def byte_size(self) -> int:
@@ -27,28 +38,12 @@ class PubFile:
 
     @property
     def file_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._file_id
 
-    @file_id.setter
-    def file_id(self, file_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._file_id = file_id
-
     @property
     def content(self) -> bytes:
         return self._content
 
-    @content.setter
-    def content(self, content: bytes) -> None:
-        self._content = content
-
     @staticmethod
     def serialize(writer: EoWriter, data: "PubFile") -> None:
         """
@@ -80,14 +75,14 @@ class PubFile:
         Returns:
             PubFile: The data to serialize.
         """
-        data: PubFile = PubFile()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._file_id = reader.get_char()
-            data._content = reader.get_bytes(reader.remaining)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            file_id = reader.get_char()
+            content = reader.get_bytes(reader.remaining)
+            result = PubFile(file_id=file_id, content=content)
+            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_dialog_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 .dialog_quest_entry import DialogQuestEntry
 from .dialog_entry import DialogEntry
 from ..packet_family import PacketFamily
@@ -18,13 +19,33 @@ class QuestDialogServerPacket(Packet):
     Quest selection dialog
     """
     _byte_size: int = 0
-    _quest_count: int = None # type: ignore [assignment]
-    _behavior_id: int = None # type: ignore [assignment]
-    _quest_id: int = None # type: ignore [assignment]
-    _session_id: int = None # type: ignore [assignment]
-    _dialog_id: int = None # type: ignore [assignment]
-    _quest_entries: list[DialogQuestEntry] = None # type: ignore [assignment]
-    _dialog_entries: list[DialogEntry] = None # type: ignore [assignment]
+    _quest_count: int
+    _behavior_id: int
+    _quest_id: int
+    _session_id: int
+    _dialog_id: int
+    _quest_entries: tuple[DialogQuestEntry, ...]
+    _dialog_entries: tuple[DialogEntry, ...]
+
+    def __init__(self, *, behavior_id: int, quest_id: int, session_id: int, dialog_id: int, quest_entries: Iterable[DialogQuestEntry], dialog_entries: Iterable[DialogEntry]):
+        """
+        Create a new instance of QuestDialogServerPacket.
+
+        Args:
+            behavior_id (int): (Value range is 0-64008.)
+            quest_id (int): (Value range is 0-64008.)
+            session_id (int): (Value range is 0-64008.)
+            dialog_id (int): (Value range is 0-64008.)
+            quest_entries (Iterable[DialogQuestEntry]): (Length must be 252 or less.)
+            dialog_entries (Iterable[DialogEntry]): 
+        """
+        self._behavior_id = behavior_id
+        self._quest_id = quest_id
+        self._session_id = session_id
+        self._dialog_id = dialog_id
+        self._quest_entries = tuple(quest_entries)
+        self._quest_count = len(self._quest_entries)
+        self._dialog_entries = tuple(dialog_entries)
 
     @property
     def byte_size(self) -> int:
@@ -38,93 +59,28 @@ class QuestDialogServerPacket(Packet):
 
     @property
     def behavior_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._behavior_id
 
-    @behavior_id.setter
-    def behavior_id(self, behavior_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._behavior_id = behavior_id
-
     @property
     def quest_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._quest_id
 
-    @quest_id.setter
-    def quest_id(self, quest_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._quest_id = quest_id
-
     @property
     def session_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._session_id
 
-    @session_id.setter
-    def session_id(self, session_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._session_id = session_id
-
     @property
     def dialog_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._dialog_id
 
-    @dialog_id.setter
-    def dialog_id(self, dialog_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._dialog_id = dialog_id
-
     @property
-    def quest_entries(self) -> list[DialogQuestEntry]:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
+    def quest_entries(self) -> tuple[DialogQuestEntry, ...]:
         return self._quest_entries
 
-    @quest_entries.setter
-    def quest_entries(self, quest_entries: list[DialogQuestEntry]) -> None:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
-        self._quest_entries = quest_entries
-        self._quest_count = len(self._quest_entries)
-
     @property
-    def dialog_entries(self) -> list[DialogEntry]:
+    def dialog_entries(self) -> tuple[DialogEntry, ...]:
         return self._dialog_entries
 
-    @dialog_entries.setter
-    def dialog_entries(self, dialog_entries: list[DialogEntry]) -> None:
-        self._dialog_entries = dialog_entries
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -209,28 +165,28 @@ class QuestDialogServerPacket(Packet):
         Returns:
             QuestDialogServerPacket: The data to serialize.
         """
-        data: QuestDialogServerPacket = QuestDialogServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
-            data._quest_count = reader.get_char()
-            data._behavior_id = reader.get_short()
-            data._quest_id = reader.get_short()
-            data._session_id = reader.get_short()
-            data._dialog_id = reader.get_short()
+            quest_count = reader.get_char()
+            behavior_id = reader.get_short()
+            quest_id = reader.get_short()
+            session_id = reader.get_short()
+            dialog_id = reader.get_short()
             reader.next_chunk()
-            data._quest_entries = []
-            for i in range(data._quest_count):
-                data._quest_entries.append(DialogQuestEntry.deserialize(reader))
+            quest_entries = []
+            for i in range(quest_count):
+                quest_entries.append(DialogQuestEntry.deserialize(reader))
                 reader.next_chunk()
-            data._dialog_entries = []
+            dialog_entries = []
             while reader.remaining > 0:
-                data._dialog_entries.append(DialogEntry.deserialize(reader))
+                dialog_entries.append(DialogEntry.deserialize(reader))
                 reader.next_chunk()
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = QuestDialogServerPacket(behavior_id=behavior_id, quest_id=quest_id, session_id=session_id, dialog_id=dialog_id, quest_entries=quest_entries, dialog_entries=dialog_entries)
+            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_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:
         """
@@ -138,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
 
@@ -168,7 +163,16 @@ class QuestListServerPacket(Packet):
         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:
@@ -181,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:
             """
@@ -218,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
 
@@ -239,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:
@@ -252,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:
             """
@@ -289,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:
         """
@@ -129,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