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

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

@@ -12,9 +12,22 @@ class MapDrainDamageOther:
     Another player taking damage from a map HP drain
     """
     _byte_size: int = 0
-    _player_id: int = None # type: ignore [assignment]
-    _hp_percentage: int = None # type: ignore [assignment]
-    _damage: int = None # type: ignore [assignment]
+    _player_id: int
+    _hp_percentage: int
+    _damage: int
+
+    def __init__(self, *, player_id: int, hp_percentage: int, damage: int):
+        """
+        Create a new instance of MapDrainDamageOther.
+
+        Args:
+            player_id (int): (Value range is 0-64008.)
+            hp_percentage (int): (Value range is 0-252.)
+            damage (int): (Value range is 0-64008.)
+        """
+        self._player_id = player_id
+        self._hp_percentage = hp_percentage
+        self._damage = damage
 
     @property
     def byte_size(self) -> int:
@@ -28,52 +41,16 @@ class MapDrainDamageOther:
 
     @property
     def player_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._player_id
 
-    @player_id.setter
-    def player_id(self, player_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._player_id = player_id
-
     @property
     def hp_percentage(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._hp_percentage
 
-    @hp_percentage.setter
-    def hp_percentage(self, hp_percentage: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._hp_percentage = hp_percentage
-
     @property
     def damage(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._damage
 
-    @damage.setter
-    def damage(self, damage: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._damage = damage
-
     @staticmethod
     def serialize(writer: EoWriter, data: "MapDrainDamageOther") -> None:
         """
@@ -83,15 +60,19 @@ class MapDrainDamageOther:
             writer (EoWriter): The writer that the data will be serialized to.
             data (MapDrainDamageOther): The data to serialize.
         """
-        if data._player_id is None:
-            raise SerializationError("player_id must be provided.")
-        writer.add_short(data._player_id)
-        if data._hp_percentage is None:
-            raise SerializationError("hp_percentage must be provided.")
-        writer.add_char(data._hp_percentage)
-        if data._damage is None:
-            raise SerializationError("damage must be provided.")
-        writer.add_short(data._damage)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._player_id is None:
+                raise SerializationError("player_id must be provided.")
+            writer.add_short(data._player_id)
+            if data._hp_percentage is None:
+                raise SerializationError("hp_percentage must be provided.")
+            writer.add_char(data._hp_percentage)
+            if data._damage is None:
+                raise SerializationError("damage must be provided.")
+            writer.add_short(data._damage)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MapDrainDamageOther":
@@ -104,15 +85,15 @@ class MapDrainDamageOther:
         Returns:
             MapDrainDamageOther: The data to serialize.
         """
-        data: MapDrainDamageOther = MapDrainDamageOther()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._player_id = reader.get_short()
-            data._hp_percentage = reader.get_char()
-            data._damage = reader.get_short()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            player_id = reader.get_short()
+            hp_percentage = reader.get_char()
+            damage = reader.get_short()
+            result = MapDrainDamageOther(player_id=player_id, hp_percentage=hp_percentage, damage=damage)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -12,7 +12,16 @@ class MapFile:
     A map file (EMF)
     """
     _byte_size: int = 0
-    _content: bytes = None # type: ignore [assignment]
+    _content: bytes
+
+    def __init__(self, *, content: bytes):
+        """
+        Create a new instance of MapFile.
+
+        Args:
+            content (bytes): 
+        """
+        self._content = content
 
     @property
     def byte_size(self) -> int:
@@ -28,10 +37,6 @@ class MapFile:
     def content(self) -> bytes:
         return self._content
 
-    @content.setter
-    def content(self, content: bytes) -> None:
-        self._content = content
-
     @staticmethod
     def serialize(writer: EoWriter, data: "MapFile") -> None:
         """
@@ -41,9 +46,13 @@ class MapFile:
             writer (EoWriter): The writer that the data will be serialized to.
             data (MapFile): The data to serialize.
         """
-        if data._content is None:
-            raise SerializationError("content must be provided.")
-        writer.add_bytes(data._content)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._content is None:
+                raise SerializationError("content must be provided.")
+            writer.add_bytes(data._content)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MapFile":
@@ -56,13 +65,13 @@ class MapFile:
         Returns:
             MapFile: The data to serialize.
         """
-        data: MapFile = MapFile()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._content = reader.get_bytes(reader.remaining)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            content = reader.get_bytes(reader.remaining)
+            result = MapFile(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/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:
         """
@@ -81,9 +78,13 @@ class MarriageOpenServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (MarriageOpenServerPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_three(data._session_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_three(data._session_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MarriageOpenServerPacket":
@@ -96,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:
         """
@@ -87,13 +90,17 @@ class MarriageReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (MarriageReplyServerPacket): The data to serialize.
         """
-        if data._reply_code is None:
-            raise SerializationError("reply_code must be provided.")
-        writer.add_short(int(data._reply_code))
-        if data._reply_code == MarriageReply.Success:
-            if not isinstance(data._reply_code_data, MarriageReplyServerPacket.ReplyCodeDataSuccess):
-                raise SerializationError("Expected reply_code_data to be type MarriageReplyServerPacket.ReplyCodeDataSuccess for reply_code " + MarriageReply(data._reply_code).name + ".")
-            MarriageReplyServerPacket.ReplyCodeDataSuccess.serialize(writer, data._reply_code_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._reply_code is None:
+                raise SerializationError("reply_code must be provided.")
+            writer.add_short(int(data._reply_code))
+            if data._reply_code == MarriageReply.Success:
+                if not isinstance(data._reply_code_data, MarriageReplyServerPacket.ReplyCodeDataSuccess):
+                    raise SerializationError("Expected reply_code_data to be type MarriageReplyServerPacket.ReplyCodeDataSuccess for reply_code " + MarriageReply(data._reply_code).name + ".")
+                MarriageReplyServerPacket.ReplyCodeDataSuccess.serialize(writer, data._reply_code_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MarriageReplyServerPacket":
@@ -106,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
 
@@ -122,17 +130,25 @@ class MarriageReplyServerPacket(Packet):
         return f"MarriageReplyServerPacket(byte_size={repr(self._byte_size)}, reply_code={repr(self._reply_code)}, reply_code_data={repr(self._reply_code_data)})"
 
     ReplyCodeData = Union['MarriageReplyServerPacket.ReplyCodeDataSuccess', None]
-    ReplyCodeData.__doc__ = \
-        """
-        Data associated with different values of the `reply_code` field.
-        """
+    """
+    Data associated with different values of the `reply_code` field.
+    """
 
     class ReplyCodeDataSuccess:
         """
         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:
@@ -146,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:
             """
@@ -169,9 +173,13 @@ class MarriageReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (MarriageReplyServerPacket.ReplyCodeDataSuccess): The data to serialize.
             """
-            if data._gold_amount is None:
-                raise SerializationError("gold_amount must be provided.")
-            writer.add_int(data._gold_amount)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._gold_amount is None:
+                    raise SerializationError("gold_amount must be provided.")
+                writer.add_int(data._gold_amount)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "MarriageReplyServerPacket.ReplyCodeDataSuccess":
@@ -184,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:
         """
@@ -82,14 +80,19 @@ class MessageAcceptServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (MessageAcceptServerPacket): The data to serialize.
         """
-        if data._messages is None:
-            raise SerializationError("messages must be provided.")
-        if len(data._messages) != 4:
-            raise SerializationError(f"Expected length of messages to be exactly 4, got {len(data._messages)}.")
-        for i in range(4):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._messages is None:
+                raise SerializationError("messages must be provided.")
+            if len(data._messages) != 4:
+                raise SerializationError(f"Expected length of messages to be exactly 4, got {len(data._messages)}.")
+            for i in range(4):
+                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) -> "MessageAcceptServerPacket":
@@ -102,19 +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())
-                if i + 1 < 4:
-                    reader.next_chunk()
+                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:
         """
@@ -63,9 +68,11 @@ class MessageCloseServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (MessageCloseServerPacket): The data to serialize.
         """
-        old_writer_length: int = len(writer)
-        if len(writer) == old_writer_length:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
             writer.add_string("r")
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MessageCloseServerPacket":
@@ -78,14 +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
-            if reader.position == reader_start_position:
-                reader.get_string()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            reader.get_string()
+            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:
         """
@@ -73,9 +78,13 @@ class MessageOpenServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (MessageOpenServerPacket): The data to serialize.
         """
-        if data._message is None:
-            raise SerializationError("message must be provided.")
-        writer.add_string(data._message)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._message is None:
+                raise SerializationError("message must be provided.")
+            writer.add_string(data._message)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MessageOpenServerPacket":
@@ -88,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