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

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

@@ -12,8 +12,19 @@ class BigCoords:
     Map coordinates with 2-byte values
     """
     _byte_size: int = 0
-    _x: int = None # type: ignore [assignment]
-    _y: int = None # type: ignore [assignment]
+    _x: int
+    _y: int
+
+    def __init__(self, *, x: int, y: int):
+        """
+        Create a new instance of BigCoords.
+
+        Args:
+            x (int): (Value range is 0-64008.)
+            y (int): (Value range is 0-64008.)
+        """
+        self._x = x
+        self._y = y
 
     @property
     def byte_size(self) -> int:
@@ -27,36 +38,12 @@ class BigCoords:
 
     @property
     def x(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._x
 
-    @x.setter
-    def x(self, x: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._x = x
-
     @property
     def y(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._y
 
-    @y.setter
-    def y(self, y: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._y = y
-
     @staticmethod
     def serialize(writer: EoWriter, data: "BigCoords") -> None:
         """
@@ -66,12 +53,16 @@ class BigCoords:
             writer (EoWriter): The writer that the data will be serialized to.
             data (BigCoords): The data to serialize.
         """
-        if data._x is None:
-            raise SerializationError("x must be provided.")
-        writer.add_short(data._x)
-        if data._y is None:
-            raise SerializationError("y must be provided.")
-        writer.add_short(data._y)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._x is None:
+                raise SerializationError("x must be provided.")
+            writer.add_short(data._x)
+            if data._y is None:
+                raise SerializationError("y must be provided.")
+            writer.add_short(data._y)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "BigCoords":
@@ -84,14 +75,14 @@ class BigCoords:
         Returns:
             BigCoords: The data to serialize.
         """
-        data: BigCoords = BigCoords()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._x = reader.get_short()
-            data._y = reader.get_short()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            x = reader.get_short()
+            y = reader.get_short()
+            result = BigCoords(x=x, y=y)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/net/server/board_open_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 .board_post_listing import BoardPostListing
 from ..packet_family import PacketFamily
 from ..packet_action import PacketAction
@@ -17,9 +18,21 @@ class BoardOpenServerPacket(Packet):
     Reply to opening a town board
     """
     _byte_size: int = 0
-    _board_id: int = None # type: ignore [assignment]
-    _posts_count: int = None # type: ignore [assignment]
-    _posts: list[BoardPostListing] = None # type: ignore [assignment]
+    _board_id: int
+    _posts_count: int
+    _posts: tuple[BoardPostListing, ...]
+
+    def __init__(self, *, board_id: int, posts: Iterable[BoardPostListing]):
+        """
+        Create a new instance of BoardOpenServerPacket.
+
+        Args:
+            board_id (int): (Value range is 0-252.)
+            posts (Iterable[BoardPostListing]): (Length must be 252 or less.)
+        """
+        self._board_id = board_id
+        self._posts = tuple(posts)
+        self._posts_count = len(self._posts)
 
     @property
     def byte_size(self) -> int:
@@ -33,37 +46,12 @@ class BoardOpenServerPacket(Packet):
 
     @property
     def board_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._board_id
 
-    @board_id.setter
-    def board_id(self, board_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._board_id = board_id
-
     @property
-    def posts(self) -> list[BoardPostListing]:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
+    def posts(self) -> tuple[BoardPostListing, ...]:
         return self._posts
 
-    @posts.setter
-    def posts(self, posts: list[BoardPostListing]) -> None:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
-        self._posts = posts
-        self._posts_count = len(self._posts)
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -102,20 +90,25 @@ class BoardOpenServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (BoardOpenServerPacket): The data to serialize.
         """
-        if data._board_id is None:
-            raise SerializationError("board_id must be provided.")
-        writer.add_char(data._board_id)
-        if data._posts_count is None:
-            raise SerializationError("posts_count must be provided.")
-        writer.add_char(data._posts_count)
-        if data._posts is None:
-            raise SerializationError("posts must be provided.")
-        if len(data._posts) > 252:
-            raise SerializationError(f"Expected length of posts to be 252 or less, got {len(data._posts)}.")
-        for i in range(data._posts_count):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._board_id is None:
+                raise SerializationError("board_id must be provided.")
+            writer.add_char(data._board_id)
+            if data._posts_count is None:
+                raise SerializationError("posts_count must be provided.")
+            writer.add_char(data._posts_count)
+            if data._posts is None:
+                raise SerializationError("posts must be provided.")
+            if len(data._posts) > 252:
+                raise SerializationError(f"Expected length of posts to be 252 or less, got {len(data._posts)}.")
+            for i in range(data._posts_count):
+                BoardPostListing.serialize(writer, data._posts[i])
                 writer.add_byte(0xFF)
-            BoardPostListing.serialize(writer, data._posts[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "BoardOpenServerPacket":
@@ -128,21 +121,20 @@ class BoardOpenServerPacket(Packet):
         Returns:
             BoardOpenServerPacket: The data to serialize.
         """
-        data: BoardOpenServerPacket = BoardOpenServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
-            data._board_id = reader.get_char()
-            data._posts_count = reader.get_char()
-            data._posts = []
-            for i in range(data._posts_count):
-                data._posts.append(BoardPostListing.deserialize(reader))
-                if i + 1 < data._posts_count:
-                    reader.next_chunk()
+            board_id = reader.get_char()
+            posts_count = reader.get_char()
+            posts = []
+            for i in range(posts_count):
+                posts.append(BoardPostListing.deserialize(reader))
+                reader.next_chunk()
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = BoardOpenServerPacket(board_id=board_id, posts=posts)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -15,8 +15,19 @@ class BoardPlayerServerPacket(Packet):
     Reply to reading a post on a town board
     """
     _byte_size: int = 0
-    _post_id: int = None # type: ignore [assignment]
-    _post_body: str = None # type: ignore [assignment]
+    _post_id: int
+    _post_body: str
+
+    def __init__(self, *, post_id: int, post_body: str):
+        """
+        Create a new instance of BoardPlayerServerPacket.
+
+        Args:
+            post_id (int): (Value range is 0-64008.)
+            post_body (str): 
+        """
+        self._post_id = post_id
+        self._post_body = post_body
 
     @property
     def byte_size(self) -> int:
@@ -30,28 +41,12 @@ class BoardPlayerServerPacket(Packet):
 
     @property
     def post_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._post_id
 
-    @post_id.setter
-    def post_id(self, post_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._post_id = post_id
-
     @property
     def post_body(self) -> str:
         return self._post_body
 
-    @post_body.setter
-    def post_body(self, post_body: str) -> None:
-        self._post_body = post_body
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -90,12 +85,18 @@ class BoardPlayerServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (BoardPlayerServerPacket): The data to serialize.
         """
-        if data._post_id is None:
-            raise SerializationError("post_id must be provided.")
-        writer.add_short(data._post_id)
-        if data._post_body is None:
-            raise SerializationError("post_body must be provided.")
-        writer.add_string(data._post_body)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._post_id is None:
+                raise SerializationError("post_id must be provided.")
+            writer.add_short(data._post_id)
+            if data._post_body is None:
+                raise SerializationError("post_body must be provided.")
+            writer.add_string(data._post_body)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "BoardPlayerServerPacket":
@@ -108,16 +109,16 @@ class BoardPlayerServerPacket(Packet):
         Returns:
             BoardPlayerServerPacket: The data to serialize.
         """
-        data: BoardPlayerServerPacket = BoardPlayerServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
-            data._post_id = reader.get_short()
-            data._post_body = reader.get_string()
+            post_id = reader.get_short()
+            post_body = reader.get_string()
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = BoardPlayerServerPacket(post_id=post_id, post_body=post_body)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -12,9 +12,22 @@ class BoardPostListing:
     An entry in the list of town board posts
     """
     _byte_size: int = 0
-    _post_id: int = None # type: ignore [assignment]
-    _author: str = None # type: ignore [assignment]
-    _subject: str = None # type: ignore [assignment]
+    _post_id: int
+    _author: str
+    _subject: str
+
+    def __init__(self, *, post_id: int, author: str, subject: str):
+        """
+        Create a new instance of BoardPostListing.
+
+        Args:
+            post_id (int): (Value range is 0-64008.)
+            author (str): 
+            subject (str): 
+        """
+        self._post_id = post_id
+        self._author = author
+        self._subject = subject
 
     @property
     def byte_size(self) -> int:
@@ -28,36 +41,16 @@ class BoardPostListing:
 
     @property
     def post_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._post_id
 
-    @post_id.setter
-    def post_id(self, post_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._post_id = post_id
-
     @property
     def author(self) -> str:
         return self._author
 
-    @author.setter
-    def author(self, author: str) -> None:
-        self._author = author
-
     @property
     def subject(self) -> str:
         return self._subject
 
-    @subject.setter
-    def subject(self, subject: str) -> None:
-        self._subject = subject
-
     @staticmethod
     def serialize(writer: EoWriter, data: "BoardPostListing") -> None:
         """
@@ -67,17 +60,23 @@ class BoardPostListing:
             writer (EoWriter): The writer that the data will be serialized to.
             data (BoardPostListing): The data to serialize.
         """
-        if data._post_id is None:
-            raise SerializationError("post_id must be provided.")
-        writer.add_short(data._post_id)
-        writer.add_byte(0xFF)
-        if data._author is None:
-            raise SerializationError("author must be provided.")
-        writer.add_string(data._author)
-        writer.add_byte(0xFF)
-        if data._subject is None:
-            raise SerializationError("subject must be provided.")
-        writer.add_string(data._subject)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._post_id is None:
+                raise SerializationError("post_id must be provided.")
+            writer.add_short(data._post_id)
+            writer.add_byte(0xFF)
+            if data._author is None:
+                raise SerializationError("author must be provided.")
+            writer.add_string(data._author)
+            writer.add_byte(0xFF)
+            if data._subject is None:
+                raise SerializationError("subject must be provided.")
+            writer.add_string(data._subject)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "BoardPostListing":
@@ -90,19 +89,19 @@ class BoardPostListing:
         Returns:
             BoardPostListing: The data to serialize.
         """
-        data: BoardPostListing = BoardPostListing()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
-            data._post_id = reader.get_short()
+            post_id = reader.get_short()
             reader.next_chunk()
-            data._author = reader.get_string()
+            author = reader.get_string()
             reader.next_chunk()
-            data._subject = reader.get_string()
+            subject = reader.get_string()
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = BoardPostListing(post_id=post_id, author=author, subject=subject)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/net/server/book_reply_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 .character_icon import CharacterIcon
 from .character_details import CharacterDetails
 from ..packet_family import PacketFamily
@@ -18,9 +19,22 @@ class BookReplyServerPacket(Packet):
     Reply to requesting a book
     """
     _byte_size: int = 0
-    _details: CharacterDetails = None # type: ignore [assignment]
-    _icon: CharacterIcon = None # type: ignore [assignment]
-    _quest_names: list[str] = None # type: ignore [assignment]
+    _details: CharacterDetails
+    _icon: CharacterIcon
+    _quest_names: tuple[str, ...]
+
+    def __init__(self, *, details: CharacterDetails, icon: CharacterIcon, quest_names: Iterable[str]):
+        """
+        Create a new instance of BookReplyServerPacket.
+
+        Args:
+            details (CharacterDetails): 
+            icon (CharacterIcon): 
+            quest_names (Iterable[str]): 
+        """
+        self._details = details
+        self._icon = icon
+        self._quest_names = tuple(quest_names)
 
     @property
     def byte_size(self) -> int:
@@ -36,26 +50,14 @@ class BookReplyServerPacket(Packet):
     def details(self) -> CharacterDetails:
         return self._details
 
-    @details.setter
-    def details(self, details: CharacterDetails) -> None:
-        self._details = details
-
     @property
     def icon(self) -> CharacterIcon:
         return self._icon
 
-    @icon.setter
-    def icon(self, icon: CharacterIcon) -> None:
-        self._icon = icon
-
     @property
-    def quest_names(self) -> list[str]:
+    def quest_names(self) -> tuple[str, ...]:
         return self._quest_names
 
-    @quest_names.setter
-    def quest_names(self, quest_names: list[str]) -> None:
-        self._quest_names = quest_names
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -94,19 +96,24 @@ class BookReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (BookReplyServerPacket): The data to serialize.
         """
-        if data._details is None:
-            raise SerializationError("details must be provided.")
-        CharacterDetails.serialize(writer, data._details)
-        if data._icon is None:
-            raise SerializationError("icon must be provided.")
-        writer.add_char(int(data._icon))
-        writer.add_byte(0xFF)
-        if data._quest_names is None:
-            raise SerializationError("quest_names must be provided.")
-        for i in range(len(data._quest_names)):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._details is None:
+                raise SerializationError("details must be provided.")
+            CharacterDetails.serialize(writer, data._details)
+            if data._icon is None:
+                raise SerializationError("icon must be provided.")
+            writer.add_char(int(data._icon))
+            writer.add_byte(0xFF)
+            if data._quest_names is None:
+                raise SerializationError("quest_names must be provided.")
+            for i in range(len(data._quest_names)):
+                writer.add_string(data._quest_names[i])
                 writer.add_byte(0xFF)
-            writer.add_string(data._quest_names[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "BookReplyServerPacket":
@@ -119,21 +126,21 @@ class BookReplyServerPacket(Packet):
         Returns:
             BookReplyServerPacket: The data to serialize.
         """
-        data: BookReplyServerPacket = BookReplyServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
-            data._details = CharacterDetails.deserialize(reader)
-            data._icon = CharacterIcon(reader.get_char())
+            details = CharacterDetails.deserialize(reader)
+            icon = CharacterIcon(reader.get_char())
             reader.next_chunk()
-            data._quest_names = []
+            quest_names = []
             while reader.remaining > 0:
-                data._quest_names.append(reader.get_string())
+                quest_names.append(reader.get_string())
                 reader.next_chunk()
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = BookReplyServerPacket(details=details, icon=icon, quest_names=quest_names)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode