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

eolib/protocol/_generated/net/server/admin_interact_list_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 ..three_item import ThreeItem
 from ..packet_family import PacketFamily
 from ..packet_action import PacketAction
@@ -18,11 +19,28 @@ class AdminInteractListServerPacket(Packet):
     Admin character inventory popup
     """
     _byte_size: int = 0
-    _name: str = None # type: ignore [assignment]
-    _usage: int = None # type: ignore [assignment]
-    _gold_bank: int = None # type: ignore [assignment]
-    _inventory: list[Item] = None # type: ignore [assignment]
-    _bank: list[ThreeItem] = None # type: ignore [assignment]
+    _name: str
+    _usage: int
+    _gold_bank: int
+    _inventory: tuple[Item, ...]
+    _bank: tuple[ThreeItem, ...]
+
+    def __init__(self, *, name: str, usage: int, gold_bank: int, inventory: Iterable[Item], bank: Iterable[ThreeItem]):
+        """
+        Create a new instance of AdminInteractListServerPacket.
+
+        Args:
+            name (str): 
+            usage (int): (Value range is 0-4097152080.)
+            gold_bank (int): (Value range is 0-4097152080.)
+            inventory (Iterable[Item]): 
+            bank (Iterable[ThreeItem]): 
+        """
+        self._name = name
+        self._usage = usage
+        self._gold_bank = gold_bank
+        self._inventory = tuple(inventory)
+        self._bank = tuple(bank)
 
     @property
     def byte_size(self) -> int:
@@ -38,58 +56,22 @@ class AdminInteractListServerPacket(Packet):
     def name(self) -> str:
         return self._name
 
-    @name.setter
-    def name(self, name: str) -> None:
-        self._name = name
-
     @property
     def usage(self) -> int:
-        """
-        Note:
-          - Value range is 0-4097152080.
-        """
         return self._usage
 
-    @usage.setter
-    def usage(self, usage: int) -> None:
-        """
-        Note:
-          - Value range is 0-4097152080.
-        """
-        self._usage = usage
-
     @property
     def gold_bank(self) -> int:
-        """
-        Note:
-          - Value range is 0-4097152080.
-        """
         return self._gold_bank
 
-    @gold_bank.setter
-    def gold_bank(self, gold_bank: int) -> None:
-        """
-        Note:
-          - Value range is 0-4097152080.
-        """
-        self._gold_bank = gold_bank
-
     @property
-    def inventory(self) -> list[Item]:
+    def inventory(self) -> tuple[Item, ...]:
         return self._inventory
 
-    @inventory.setter
-    def inventory(self, inventory: list[Item]) -> None:
-        self._inventory = inventory
-
     @property
-    def bank(self) -> list[ThreeItem]:
+    def bank(self) -> tuple[ThreeItem, ...]:
         return self._bank
 
-    @bank.setter
-    def bank(self, bank: list[ThreeItem]) -> None:
-        self._bank = bank
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -128,27 +110,33 @@ class AdminInteractListServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (AdminInteractListServerPacket): 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._usage is None:
-            raise SerializationError("usage must be provided.")
-        writer.add_int(data._usage)
-        writer.add_byte(0xFF)
-        if data._gold_bank is None:
-            raise SerializationError("gold_bank must be provided.")
-        writer.add_int(data._gold_bank)
-        writer.add_byte(0xFF)
-        if data._inventory is None:
-            raise SerializationError("inventory must be provided.")
-        for i in range(len(data._inventory)):
-            Item.serialize(writer, data._inventory[i])
-        writer.add_byte(0xFF)
-        if data._bank is None:
-            raise SerializationError("bank must be provided.")
-        for i in range(len(data._bank)):
-            ThreeItem.serialize(writer, data._bank[i])
+        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._usage is None:
+                raise SerializationError("usage must be provided.")
+            writer.add_int(data._usage)
+            writer.add_byte(0xFF)
+            if data._gold_bank is None:
+                raise SerializationError("gold_bank must be provided.")
+            writer.add_int(data._gold_bank)
+            writer.add_byte(0xFF)
+            if data._inventory is None:
+                raise SerializationError("inventory must be provided.")
+            for i in range(len(data._inventory)):
+                Item.serialize(writer, data._inventory[i])
+            writer.add_byte(0xFF)
+            if data._bank is None:
+                raise SerializationError("bank must be provided.")
+            for i in range(len(data._bank)):
+                ThreeItem.serialize(writer, data._bank[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "AdminInteractListServerPacket":
@@ -161,29 +149,29 @@ class AdminInteractListServerPacket(Packet):
         Returns:
             AdminInteractListServerPacket: The data to serialize.
         """
-        data: AdminInteractListServerPacket = AdminInteractListServerPacket()
         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._usage = reader.get_int()
+            usage = reader.get_int()
             reader.next_chunk()
-            data._gold_bank = reader.get_int()
+            gold_bank = reader.get_int()
             reader.next_chunk()
             inventory_length = int(reader.remaining / 6)
-            data._inventory = []
+            inventory = []
             for i in range(inventory_length):
-                data._inventory.append(Item.deserialize(reader))
+                inventory.append(Item.deserialize(reader))
             reader.next_chunk()
             bank_length = int(reader.remaining / 5)
-            data._bank = []
+            bank = []
             for i in range(bank_length):
-                data._bank.append(ThreeItem.deserialize(reader))
+                bank.append(ThreeItem.deserialize(reader))
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = AdminInteractListServerPacket(name=name, usage=usage, gold_bank=gold_bank, inventory=inventory, bank=bank)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -15,7 +15,16 @@ class AdminInteractRemoveServerPacket(Packet):
     Nearby player disappearing (admin hide)
     """
     _byte_size: int = 0
-    _player_id: int = None # type: ignore [assignment]
+    _player_id: int
+
+    def __init__(self, *, player_id: int):
+        """
+        Create a new instance of AdminInteractRemoveServerPacket.
+
+        Args:
+            player_id (int): (Value range is 0-64008.)
+        """
+        self._player_id = player_id
 
     @property
     def byte_size(self) -> int:
@@ -29,20 +38,8 @@ class AdminInteractRemoveServerPacket(Packet):
 
     @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
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -81,9 +78,13 @@ class AdminInteractRemoveServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (AdminInteractRemoveServerPacket): The data to serialize.
         """
-        if data._player_id is None:
-            raise SerializationError("player_id must be provided.")
-        writer.add_short(data._player_id)
+        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)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "AdminInteractRemoveServerPacket":
@@ -96,13 +97,13 @@ class AdminInteractRemoveServerPacket(Packet):
         Returns:
             AdminInteractRemoveServerPacket: The data to serialize.
         """
-        data: AdminInteractRemoveServerPacket = AdminInteractRemoveServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._player_id = reader.get_short()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            player_id = reader.get_short()
+            result = AdminInteractRemoveServerPacket(player_id=player_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/admin_interact_reply_server_packet.py

@@ -17,8 +17,19 @@ class AdminInteractReplyServerPacket(Packet):
     Incoming admin message
     """
     _byte_size: int = 0
-    _message_type: AdminMessageType = None # type: ignore [assignment]
-    _message_type_data: 'AdminInteractReplyServerPacket.MessageTypeData' = None
+    _message_type: AdminMessageType
+    _message_type_data: 'AdminInteractReplyServerPacket.MessageTypeData'
+
+    def __init__(self, *, message_type: AdminMessageType, message_type_data: 'AdminInteractReplyServerPacket.MessageTypeData' = None):
+        """
+        Create a new instance of AdminInteractReplyServerPacket.
+
+        Args:
+            message_type (AdminMessageType): 
+            message_type_data (AdminInteractReplyServerPacket.MessageTypeData): Data associated with the `message_type` field.
+        """
+        self._message_type = message_type
+        self._message_type_data = message_type_data
 
     @property
     def byte_size(self) -> int:
@@ -34,21 +45,13 @@ class AdminInteractReplyServerPacket(Packet):
     def message_type(self) -> AdminMessageType:
         return self._message_type
 
-    @message_type.setter
-    def message_type(self, message_type: AdminMessageType) -> None:
-        self._message_type = message_type
-
     @property
     def message_type_data(self) -> 'AdminInteractReplyServerPacket.MessageTypeData':
         """
-        AdminInteractReplyServerPacket.MessageTypeData: Gets or sets the data associated with the `message_type` field.
+        AdminInteractReplyServerPacket.MessageTypeData: Data associated with the `message_type` field.
         """
         return self._message_type_data
 
-    @message_type_data.setter
-    def message_type_data(self, message_type_data: 'AdminInteractReplyServerPacket.MessageTypeData') -> None:
-        self._message_type_data = message_type_data
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -87,18 +90,24 @@ class AdminInteractReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (AdminInteractReplyServerPacket): The data to serialize.
         """
-        if data._message_type is None:
-            raise SerializationError("message_type must be provided.")
-        writer.add_char(int(data._message_type))
-        writer.add_byte(0xFF)
-        if data._message_type == AdminMessageType.Message:
-            if not isinstance(data._message_type_data, AdminInteractReplyServerPacket.MessageTypeDataMessage):
-                raise SerializationError("Expected message_type_data to be type AdminInteractReplyServerPacket.MessageTypeDataMessage for message_type " + AdminMessageType(data._message_type).name + ".")
-            AdminInteractReplyServerPacket.MessageTypeDataMessage.serialize(writer, data._message_type_data)
-        elif data._message_type == AdminMessageType.Report:
-            if not isinstance(data._message_type_data, AdminInteractReplyServerPacket.MessageTypeDataReport):
-                raise SerializationError("Expected message_type_data to be type AdminInteractReplyServerPacket.MessageTypeDataReport for message_type " + AdminMessageType(data._message_type).name + ".")
-            AdminInteractReplyServerPacket.MessageTypeDataReport.serialize(writer, data._message_type_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._message_type is None:
+                raise SerializationError("message_type must be provided.")
+            writer.add_char(int(data._message_type))
+            writer.add_byte(0xFF)
+            if data._message_type == AdminMessageType.Message:
+                if not isinstance(data._message_type_data, AdminInteractReplyServerPacket.MessageTypeDataMessage):
+                    raise SerializationError("Expected message_type_data to be type AdminInteractReplyServerPacket.MessageTypeDataMessage for message_type " + AdminMessageType(data._message_type).name + ".")
+                AdminInteractReplyServerPacket.MessageTypeDataMessage.serialize(writer, data._message_type_data)
+            elif data._message_type == AdminMessageType.Report:
+                if not isinstance(data._message_type_data, AdminInteractReplyServerPacket.MessageTypeDataReport):
+                    raise SerializationError("Expected message_type_data to be type AdminInteractReplyServerPacket.MessageTypeDataReport for message_type " + AdminMessageType(data._message_type).name + ".")
+                AdminInteractReplyServerPacket.MessageTypeDataReport.serialize(writer, data._message_type_data)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "AdminInteractReplyServerPacket":
@@ -111,20 +120,21 @@ class AdminInteractReplyServerPacket(Packet):
         Returns:
             AdminInteractReplyServerPacket: The data to serialize.
         """
-        data: AdminInteractReplyServerPacket = AdminInteractReplyServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
-            data._message_type = AdminMessageType(reader.get_char())
+            message_type = AdminMessageType(reader.get_char())
             reader.next_chunk()
-            if data._message_type == AdminMessageType.Message:
-                data._message_type_data = AdminInteractReplyServerPacket.MessageTypeDataMessage.deserialize(reader)
-            elif data._message_type == AdminMessageType.Report:
-                data._message_type_data = AdminInteractReplyServerPacket.MessageTypeDataReport.deserialize(reader)
+            message_type_data: AdminInteractReplyServerPacket.MessageTypeData = None
+            if message_type == AdminMessageType.Message:
+                message_type_data = AdminInteractReplyServerPacket.MessageTypeDataMessage.deserialize(reader)
+            elif message_type == AdminMessageType.Report:
+                message_type_data = AdminInteractReplyServerPacket.MessageTypeDataReport.deserialize(reader)
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = AdminInteractReplyServerPacket(message_type=message_type, message_type_data=message_type_data)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -132,18 +142,28 @@ class AdminInteractReplyServerPacket(Packet):
         return f"AdminInteractReplyServerPacket(byte_size={repr(self._byte_size)}, message_type={repr(self._message_type)}, message_type_data={repr(self._message_type_data)})"
 
     MessageTypeData = Union['AdminInteractReplyServerPacket.MessageTypeDataMessage', 'AdminInteractReplyServerPacket.MessageTypeDataReport', None]
-    MessageTypeData.__doc__ = \
-        """
-        Data associated with different values of the `message_type` field.
-        """
+    """
+    Data associated with different values of the `message_type` field.
+    """
 
     class MessageTypeDataMessage:
         """
         Data associated with message_type value AdminMessageType.Message
         """
         _byte_size: int = 0
-        _player_name: str = None # type: ignore [assignment]
-        _message: str = None # type: ignore [assignment]
+        _player_name: str
+        _message: str
+
+        def __init__(self, *, player_name: str, message: str):
+            """
+            Create a new instance of AdminInteractReplyServerPacket.MessageTypeDataMessage.
+
+            Args:
+                player_name (str): 
+                message (str): 
+            """
+            self._player_name = player_name
+            self._message = message
 
         @property
         def byte_size(self) -> int:
@@ -159,18 +179,10 @@ class AdminInteractReplyServerPacket(Packet):
         def player_name(self) -> str:
             return self._player_name
 
-        @player_name.setter
-        def player_name(self, player_name: str) -> None:
-            self._player_name = player_name
-
         @property
         def message(self) -> str:
             return self._message
 
-        @message.setter
-        def message(self, message: str) -> None:
-            self._message = message
-
         @staticmethod
         def serialize(writer: EoWriter, data: "AdminInteractReplyServerPacket.MessageTypeDataMessage") -> None:
             """
@@ -180,14 +192,18 @@ class AdminInteractReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (AdminInteractReplyServerPacket.MessageTypeDataMessage): The data to serialize.
             """
-            if data._player_name is None:
-                raise SerializationError("player_name must be provided.")
-            writer.add_string(data._player_name)
-            writer.add_byte(0xFF)
-            if data._message is None:
-                raise SerializationError("message must be provided.")
-            writer.add_string(data._message)
-            writer.add_byte(0xFF)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._player_name is None:
+                    raise SerializationError("player_name must be provided.")
+                writer.add_string(data._player_name)
+                writer.add_byte(0xFF)
+                if data._message is None:
+                    raise SerializationError("message must be provided.")
+                writer.add_string(data._message)
+                writer.add_byte(0xFF)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "AdminInteractReplyServerPacket.MessageTypeDataMessage":
@@ -200,16 +216,16 @@ class AdminInteractReplyServerPacket(Packet):
             Returns:
                 AdminInteractReplyServerPacket.MessageTypeDataMessage: The data to serialize.
             """
-            data: AdminInteractReplyServerPacket.MessageTypeDataMessage = AdminInteractReplyServerPacket.MessageTypeDataMessage()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._player_name = reader.get_string()
+                player_name = reader.get_string()
                 reader.next_chunk()
-                data._message = reader.get_string()
+                message = reader.get_string()
                 reader.next_chunk()
-                data._byte_size = reader.position - reader_start_position
-                return data
+                result = AdminInteractReplyServerPacket.MessageTypeDataMessage(player_name=player_name, message=message)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -221,9 +237,22 @@ class AdminInteractReplyServerPacket(Packet):
         Data associated with message_type value AdminMessageType.Report
         """
         _byte_size: int = 0
-        _player_name: str = None # type: ignore [assignment]
-        _message: str = None # type: ignore [assignment]
-        _reportee_name: str = None # type: ignore [assignment]
+        _player_name: str
+        _message: str
+        _reportee_name: str
+
+        def __init__(self, *, player_name: str, message: str, reportee_name: str):
+            """
+            Create a new instance of AdminInteractReplyServerPacket.MessageTypeDataReport.
+
+            Args:
+                player_name (str): 
+                message (str): 
+                reportee_name (str): 
+            """
+            self._player_name = player_name
+            self._message = message
+            self._reportee_name = reportee_name
 
         @property
         def byte_size(self) -> int:
@@ -239,26 +268,14 @@ class AdminInteractReplyServerPacket(Packet):
         def player_name(self) -> str:
             return self._player_name
 
-        @player_name.setter
-        def player_name(self, player_name: str) -> None:
-            self._player_name = player_name
-
         @property
         def message(self) -> str:
             return self._message
 
-        @message.setter
-        def message(self, message: str) -> None:
-            self._message = message
-
         @property
         def reportee_name(self) -> str:
             return self._reportee_name
 
-        @reportee_name.setter
-        def reportee_name(self, reportee_name: str) -> None:
-            self._reportee_name = reportee_name
-
         @staticmethod
         def serialize(writer: EoWriter, data: "AdminInteractReplyServerPacket.MessageTypeDataReport") -> None:
             """
@@ -268,18 +285,22 @@ class AdminInteractReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (AdminInteractReplyServerPacket.MessageTypeDataReport): The data to serialize.
             """
-            if data._player_name is None:
-                raise SerializationError("player_name must be provided.")
-            writer.add_string(data._player_name)
-            writer.add_byte(0xFF)
-            if data._message is None:
-                raise SerializationError("message must be provided.")
-            writer.add_string(data._message)
-            writer.add_byte(0xFF)
-            if data._reportee_name is None:
-                raise SerializationError("reportee_name must be provided.")
-            writer.add_string(data._reportee_name)
-            writer.add_byte(0xFF)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._player_name is None:
+                    raise SerializationError("player_name must be provided.")
+                writer.add_string(data._player_name)
+                writer.add_byte(0xFF)
+                if data._message is None:
+                    raise SerializationError("message must be provided.")
+                writer.add_string(data._message)
+                writer.add_byte(0xFF)
+                if data._reportee_name is None:
+                    raise SerializationError("reportee_name must be provided.")
+                writer.add_string(data._reportee_name)
+                writer.add_byte(0xFF)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "AdminInteractReplyServerPacket.MessageTypeDataReport":
@@ -292,18 +313,18 @@ class AdminInteractReplyServerPacket(Packet):
             Returns:
                 AdminInteractReplyServerPacket.MessageTypeDataReport: The data to serialize.
             """
-            data: AdminInteractReplyServerPacket.MessageTypeDataReport = AdminInteractReplyServerPacket.MessageTypeDataReport()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._player_name = reader.get_string()
+                player_name = reader.get_string()
                 reader.next_chunk()
-                data._message = reader.get_string()
+                message = reader.get_string()
                 reader.next_chunk()
-                data._reportee_name = reader.get_string()
+                reportee_name = reader.get_string()
                 reader.next_chunk()
-                data._byte_size = reader.position - reader_start_position
-                return data
+                result = AdminInteractReplyServerPacket.MessageTypeDataReport(player_name=player_name, message=message, reportee_name=reportee_name)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode