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

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

@@ -17,10 +17,25 @@ class PaperdollRemoveServerPacket(Packet):
     Reply to unequipping an item
     """
     _byte_size: int = 0
-    _change: AvatarChange = None # type: ignore [assignment]
-    _item_id: int = None # type: ignore [assignment]
-    _sub_loc: int = None # type: ignore [assignment]
-    _stats: CharacterStatsEquipmentChange = None # type: ignore [assignment]
+    _change: AvatarChange
+    _item_id: int
+    _sub_loc: int
+    _stats: CharacterStatsEquipmentChange
+
+    def __init__(self, *, change: AvatarChange, item_id: int, sub_loc: int, stats: CharacterStatsEquipmentChange):
+        """
+        Create a new instance of PaperdollRemoveServerPacket.
+
+        Args:
+            change (AvatarChange): 
+            item_id (int): (Value range is 0-64008.)
+            sub_loc (int): (Value range is 0-252.)
+            stats (CharacterStatsEquipmentChange): 
+        """
+        self._change = change
+        self._item_id = item_id
+        self._sub_loc = sub_loc
+        self._stats = stats
 
     @property
     def byte_size(self) -> int:
@@ -36,50 +51,18 @@ class PaperdollRemoveServerPacket(Packet):
     def change(self) -> AvatarChange:
         return self._change
 
-    @change.setter
-    def change(self, change: AvatarChange) -> None:
-        self._change = change
-
     @property
     def item_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._item_id
 
-    @item_id.setter
-    def item_id(self, item_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._item_id = item_id
-
     @property
     def sub_loc(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._sub_loc
 
-    @sub_loc.setter
-    def sub_loc(self, sub_loc: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._sub_loc = sub_loc
-
     @property
     def stats(self) -> CharacterStatsEquipmentChange:
         return self._stats
 
-    @stats.setter
-    def stats(self, stats: CharacterStatsEquipmentChange) -> None:
-        self._stats = stats
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -118,18 +101,22 @@ class PaperdollRemoveServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PaperdollRemoveServerPacket): The data to serialize.
         """
-        if data._change is None:
-            raise SerializationError("change must be provided.")
-        AvatarChange.serialize(writer, data._change)
-        if data._item_id is None:
-            raise SerializationError("item_id must be provided.")
-        writer.add_short(data._item_id)
-        if data._sub_loc is None:
-            raise SerializationError("sub_loc must be provided.")
-        writer.add_char(data._sub_loc)
-        if data._stats is None:
-            raise SerializationError("stats must be provided.")
-        CharacterStatsEquipmentChange.serialize(writer, data._stats)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._change is None:
+                raise SerializationError("change must be provided.")
+            AvatarChange.serialize(writer, data._change)
+            if data._item_id is None:
+                raise SerializationError("item_id must be provided.")
+            writer.add_short(data._item_id)
+            if data._sub_loc is None:
+                raise SerializationError("sub_loc must be provided.")
+            writer.add_char(data._sub_loc)
+            if data._stats is None:
+                raise SerializationError("stats must be provided.")
+            CharacterStatsEquipmentChange.serialize(writer, data._stats)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PaperdollRemoveServerPacket":
@@ -142,16 +129,16 @@ class PaperdollRemoveServerPacket(Packet):
         Returns:
             PaperdollRemoveServerPacket: The data to serialize.
         """
-        data: PaperdollRemoveServerPacket = PaperdollRemoveServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._change = AvatarChange.deserialize(reader)
-            data._item_id = reader.get_short()
-            data._sub_loc = reader.get_char()
-            data._stats = CharacterStatsEquipmentChange.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            change = AvatarChange.deserialize(reader)
+            item_id = reader.get_short()
+            sub_loc = reader.get_char()
+            stats = CharacterStatsEquipmentChange.deserialize(reader)
+            result = PaperdollRemoveServerPacket(change=change, item_id=item_id, sub_loc=sub_loc, stats=stats)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -18,9 +18,22 @@ class PaperdollReplyServerPacket(Packet):
     Reply to requesting a paperdoll
     """
     _byte_size: int = 0
-    _details: CharacterDetails = None # type: ignore [assignment]
-    _equipment: EquipmentPaperdoll = None # type: ignore [assignment]
-    _icon: CharacterIcon = None # type: ignore [assignment]
+    _details: CharacterDetails
+    _equipment: EquipmentPaperdoll
+    _icon: CharacterIcon
+
+    def __init__(self, *, details: CharacterDetails, equipment: EquipmentPaperdoll, icon: CharacterIcon):
+        """
+        Create a new instance of PaperdollReplyServerPacket.
+
+        Args:
+            details (CharacterDetails): 
+            equipment (EquipmentPaperdoll): 
+            icon (CharacterIcon): 
+        """
+        self._details = details
+        self._equipment = equipment
+        self._icon = icon
 
     @property
     def byte_size(self) -> int:
@@ -36,26 +49,14 @@ class PaperdollReplyServerPacket(Packet):
     def details(self) -> CharacterDetails:
         return self._details
 
-    @details.setter
-    def details(self, details: CharacterDetails) -> None:
-        self._details = details
-
     @property
     def equipment(self) -> EquipmentPaperdoll:
         return self._equipment
 
-    @equipment.setter
-    def equipment(self, equipment: EquipmentPaperdoll) -> None:
-        self._equipment = equipment
-
     @property
     def icon(self) -> CharacterIcon:
         return self._icon
 
-    @icon.setter
-    def icon(self, icon: CharacterIcon) -> None:
-        self._icon = icon
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -94,15 +95,21 @@ class PaperdollReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PaperdollReplyServerPacket): The data to serialize.
         """
-        if data._details is None:
-            raise SerializationError("details must be provided.")
-        CharacterDetails.serialize(writer, data._details)
-        if data._equipment is None:
-            raise SerializationError("equipment must be provided.")
-        EquipmentPaperdoll.serialize(writer, data._equipment)
-        if data._icon is None:
-            raise SerializationError("icon must be provided.")
-        writer.add_char(int(data._icon))
+        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._equipment is None:
+                raise SerializationError("equipment must be provided.")
+            EquipmentPaperdoll.serialize(writer, data._equipment)
+            if data._icon is None:
+                raise SerializationError("icon must be provided.")
+            writer.add_char(int(data._icon))
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PaperdollReplyServerPacket":
@@ -115,17 +122,17 @@ class PaperdollReplyServerPacket(Packet):
         Returns:
             PaperdollReplyServerPacket: The data to serialize.
         """
-        data: PaperdollReplyServerPacket = PaperdollReplyServerPacket()
         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._equipment = EquipmentPaperdoll.deserialize(reader)
-            data._icon = CharacterIcon(reader.get_char())
+            details = CharacterDetails.deserialize(reader)
+            equipment = EquipmentPaperdoll.deserialize(reader)
+            icon = CharacterIcon(reader.get_char())
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = PaperdollReplyServerPacket(details=details, equipment=equipment, icon=icon)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

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

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

@@ -15,8 +15,19 @@ class PartyAgreeServerPacket(Packet):
     Party member list update
     """
     _byte_size: int = 0
-    _player_id: int = None # type: ignore [assignment]
-    _hp_percentage: int = None # type: ignore [assignment]
+    _player_id: int
+    _hp_percentage: int
+
+    def __init__(self, *, player_id: int, hp_percentage: int):
+        """
+        Create a new instance of PartyAgreeServerPacket.
+
+        Args:
+            player_id (int): (Value range is 0-64008.)
+            hp_percentage (int): (Value range is 0-252.)
+        """
+        self._player_id = player_id
+        self._hp_percentage = hp_percentage
 
     @property
     def byte_size(self) -> int:
@@ -30,36 +41,12 @@ class PartyAgreeServerPacket(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
-
     @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
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -98,12 +85,16 @@ class PartyAgreeServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PartyAgreeServerPacket): 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)
+        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)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PartyAgreeServerPacket":
@@ -116,14 +107,14 @@ class PartyAgreeServerPacket(Packet):
         Returns:
             PartyAgreeServerPacket: The data to serialize.
         """
-        data: PartyAgreeServerPacket = PartyAgreeServerPacket()
         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._byte_size = reader.position - reader_start_position
-            return data
+            player_id = reader.get_short()
+            hp_percentage = reader.get_char()
+            result = PartyAgreeServerPacket(player_id=player_id, hp_percentage=hp_percentage)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -15,6 +15,11 @@ class PartyCloseServerPacket(Packet):
     """
     _byte_size: int = 0
 
+    def __init__(self):
+        """
+        Create a new instance of PartyCloseServerPacket.
+        """
+
     @property
     def byte_size(self) -> int:
         """
@@ -63,9 +68,11 @@ class PartyCloseServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PartyCloseServerPacket): 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_byte(255)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PartyCloseServerPacket":
@@ -78,14 +85,13 @@ class PartyCloseServerPacket(Packet):
         Returns:
             PartyCloseServerPacket: The data to serialize.
         """
-        data: PartyCloseServerPacket = PartyCloseServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            if reader.position == reader_start_position:
-                reader.get_byte()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            reader.get_byte()
+            result = PartyCloseServerPacket()
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/net/server/party_create_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 .party_member import PartyMember
 from ..packet_family import PacketFamily
 from ..packet_action import PacketAction
@@ -17,7 +18,16 @@ class PartyCreateServerPacket(Packet):
     Member list received when party is first joined
     """
     _byte_size: int = 0
-    _members: list[PartyMember] = None # type: ignore [assignment]
+    _members: tuple[PartyMember, ...]
+
+    def __init__(self, *, members: Iterable[PartyMember]):
+        """
+        Create a new instance of PartyCreateServerPacket.
+
+        Args:
+            members (Iterable[PartyMember]): 
+        """
+        self._members = tuple(members)
 
     @property
     def byte_size(self) -> int:
@@ -30,13 +40,9 @@ class PartyCreateServerPacket(Packet):
         return self._byte_size
 
     @property
-    def members(self) -> list[PartyMember]:
+    def members(self) -> tuple[PartyMember, ...]:
         return self._members
 
-    @members.setter
-    def members(self, members: list[PartyMember]) -> None:
-        self._members = members
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -75,12 +81,17 @@ class PartyCreateServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PartyCreateServerPacket): The data to serialize.
         """
-        if data._members is None:
-            raise SerializationError("members must be provided.")
-        for i in range(len(data._members)):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._members is None:
+                raise SerializationError("members must be provided.")
+            for i in range(len(data._members)):
+                PartyMember.serialize(writer, data._members[i])
                 writer.add_byte(0xFF)
-            PartyMember.serialize(writer, data._members[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PartyCreateServerPacket":
@@ -93,18 +104,18 @@ class PartyCreateServerPacket(Packet):
         Returns:
             PartyCreateServerPacket: The data to serialize.
         """
-        data: PartyCreateServerPacket = PartyCreateServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
-            data._members = []
+            members = []
             while reader.remaining > 0:
-                data._members.append(PartyMember.deserialize(reader))
+                members.append(PartyMember.deserialize(reader))
                 reader.next_chunk()
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = PartyCreateServerPacket(members=members)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode