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

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

@@ -15,9 +15,22 @@ class RecoverAgreeServerPacket(Packet):
     Nearby player gained HP
     """
     _byte_size: int = 0
-    _player_id: int = None # type: ignore [assignment]
-    _heal_hp: int = None # type: ignore [assignment]
-    _hp_percentage: int = None # type: ignore [assignment]
+    _player_id: int
+    _heal_hp: int
+    _hp_percentage: int
+
+    def __init__(self, *, player_id: int, heal_hp: int, hp_percentage: int):
+        """
+        Create a new instance of RecoverAgreeServerPacket.
+
+        Args:
+            player_id (int): (Value range is 0-64008.)
+            heal_hp (int): (Value range is 0-4097152080.)
+            hp_percentage (int): (Value range is 0-252.)
+        """
+        self._player_id = player_id
+        self._heal_hp = heal_hp
+        self._hp_percentage = hp_percentage
 
     @property
     def byte_size(self) -> int:
@@ -31,52 +44,16 @@ class RecoverAgreeServerPacket(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 heal_hp(self) -> int:
-        """
-        Note:
-          - Value range is 0-4097152080.
-        """
         return self._heal_hp
 
-    @heal_hp.setter
-    def heal_hp(self, heal_hp: int) -> None:
-        """
-        Note:
-          - Value range is 0-4097152080.
-        """
-        self._heal_hp = heal_hp
-
     @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:
         """
@@ -115,15 +92,19 @@ class RecoverAgreeServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (RecoverAgreeServerPacket): 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._heal_hp is None:
-            raise SerializationError("heal_hp must be provided.")
-        writer.add_int(data._heal_hp)
-        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._heal_hp is None:
+                raise SerializationError("heal_hp must be provided.")
+            writer.add_int(data._heal_hp)
+            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) -> "RecoverAgreeServerPacket":
@@ -136,15 +117,15 @@ class RecoverAgreeServerPacket(Packet):
         Returns:
             RecoverAgreeServerPacket: The data to serialize.
         """
-        data: RecoverAgreeServerPacket = RecoverAgreeServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._player_id = reader.get_short()
-            data._heal_hp = reader.get_int()
-            data._hp_percentage = reader.get_char()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            player_id = reader.get_short()
+            heal_hp = reader.get_int()
+            hp_percentage = reader.get_char()
+            result = RecoverAgreeServerPacket(player_id=player_id, heal_hp=heal_hp, 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/recover_list_server_packet.py

@@ -16,8 +16,19 @@ class RecoverListServerPacket(Packet):
     Stats update
     """
     _byte_size: int = 0
-    _class_id: int = None # type: ignore [assignment]
-    _stats: CharacterStatsUpdate = None # type: ignore [assignment]
+    _class_id: int
+    _stats: CharacterStatsUpdate
+
+    def __init__(self, *, class_id: int, stats: CharacterStatsUpdate):
+        """
+        Create a new instance of RecoverListServerPacket.
+
+        Args:
+            class_id (int): (Value range is 0-64008.)
+            stats (CharacterStatsUpdate): 
+        """
+        self._class_id = class_id
+        self._stats = stats
 
     @property
     def byte_size(self) -> int:
@@ -31,28 +42,12 @@ class RecoverListServerPacket(Packet):
 
     @property
     def class_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._class_id
 
-    @class_id.setter
-    def class_id(self, class_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._class_id = class_id
-
     @property
     def stats(self) -> CharacterStatsUpdate:
         return self._stats
 
-    @stats.setter
-    def stats(self, stats: CharacterStatsUpdate) -> None:
-        self._stats = stats
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -91,12 +86,16 @@ class RecoverListServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (RecoverListServerPacket): The data to serialize.
         """
-        if data._class_id is None:
-            raise SerializationError("class_id must be provided.")
-        writer.add_short(data._class_id)
-        if data._stats is None:
-            raise SerializationError("stats must be provided.")
-        CharacterStatsUpdate.serialize(writer, data._stats)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._class_id is None:
+                raise SerializationError("class_id must be provided.")
+            writer.add_short(data._class_id)
+            if data._stats is None:
+                raise SerializationError("stats must be provided.")
+            CharacterStatsUpdate.serialize(writer, data._stats)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "RecoverListServerPacket":
@@ -109,14 +108,14 @@ class RecoverListServerPacket(Packet):
         Returns:
             RecoverListServerPacket: The data to serialize.
         """
-        data: RecoverListServerPacket = RecoverListServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._class_id = reader.get_short()
-            data._stats = CharacterStatsUpdate.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            class_id = reader.get_short()
+            stats = CharacterStatsUpdate.deserialize(reader)
+            result = RecoverListServerPacket(class_id=class_id, 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/recover_player_server_packet.py

@@ -15,8 +15,19 @@ class RecoverPlayerServerPacket(Packet):
     HP/TP update
     """
     _byte_size: int = 0
-    _hp: int = None # type: ignore [assignment]
-    _tp: int = None # type: ignore [assignment]
+    _hp: int
+    _tp: int
+
+    def __init__(self, *, hp: int, tp: int):
+        """
+        Create a new instance of RecoverPlayerServerPacket.
+
+        Args:
+            hp (int): (Value range is 0-64008.)
+            tp (int): (Value range is 0-64008.)
+        """
+        self._hp = hp
+        self._tp = tp
 
     @property
     def byte_size(self) -> int:
@@ -30,36 +41,12 @@ class RecoverPlayerServerPacket(Packet):
 
     @property
     def hp(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._hp
 
-    @hp.setter
-    def hp(self, hp: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._hp = hp
-
     @property
     def tp(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._tp
 
-    @tp.setter
-    def tp(self, tp: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._tp = tp
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -98,12 +85,17 @@ class RecoverPlayerServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (RecoverPlayerServerPacket): The data to serialize.
         """
-        if data._hp is None:
-            raise SerializationError("hp must be provided.")
-        writer.add_short(data._hp)
-        if data._tp is None:
-            raise SerializationError("tp must be provided.")
-        writer.add_short(data._tp)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._hp is None:
+                raise SerializationError("hp must be provided.")
+            writer.add_short(data._hp)
+            if data._tp is None:
+                raise SerializationError("tp must be provided.")
+            writer.add_short(data._tp)
+            writer.add_short(0)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "RecoverPlayerServerPacket":
@@ -116,14 +108,15 @@ class RecoverPlayerServerPacket(Packet):
         Returns:
             RecoverPlayerServerPacket: The data to serialize.
         """
-        data: RecoverPlayerServerPacket = RecoverPlayerServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._hp = reader.get_short()
-            data._tp = reader.get_short()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            hp = reader.get_short()
+            tp = reader.get_short()
+            reader.get_short()
+            result = RecoverPlayerServerPacket(hp=hp, tp=tp)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -17,11 +17,28 @@ class RecoverReplyServerPacket(Packet):
     Karma/experience update
     """
     _byte_size: int = 0
-    _experience: int = None # type: ignore [assignment]
-    _karma: int = None # type: ignore [assignment]
-    _level_up: Optional[int] = None # type: ignore [assignment]
-    _stat_points: Optional[int] = None # type: ignore [assignment]
-    _skill_points: Optional[int] = None # type: ignore [assignment]
+    _experience: int
+    _karma: int
+    _level_up: Optional[int]
+    _stat_points: Optional[int]
+    _skill_points: Optional[int]
+
+    def __init__(self, *, experience: int, karma: int, level_up: Optional[int] = None, stat_points: Optional[int] = None, skill_points: Optional[int] = None):
+        """
+        Create a new instance of RecoverReplyServerPacket.
+
+        Args:
+            experience (int): (Value range is 0-4097152080.)
+            karma (int): (Value range is 0-64008.)
+            level_up (Optional[int]): A value greater than 0 is "new level" and indicates the player leveled up. The official client reads this if the packet is larger than 6 bytes. (Value range is 0-252.)
+            stat_points (Optional[int]): The official client reads this if the player leveled up (Value range is 0-64008.)
+            skill_points (Optional[int]): The official client reads this if the player leveled up (Value range is 0-64008.)
+        """
+        self._experience = experience
+        self._karma = karma
+        self._level_up = level_up
+        self._stat_points = stat_points
+        self._skill_points = skill_points
 
     @property
     def byte_size(self) -> int:
@@ -35,98 +52,34 @@ class RecoverReplyServerPacket(Packet):
 
     @property
     def experience(self) -> int:
-        """
-        Note:
-          - Value range is 0-4097152080.
-        """
         return self._experience
 
-    @experience.setter
-    def experience(self, experience: int) -> None:
-        """
-        Note:
-          - Value range is 0-4097152080.
-        """
-        self._experience = experience
-
     @property
     def karma(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._karma
 
-    @karma.setter
-    def karma(self, karma: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._karma = karma
-
     @property
     def level_up(self) -> Optional[int]:
         """
-        A value greater than 0 is "new level" and indicates the player leveled up.
+        A value greater than 0 is "new level" and indicates the player leveled up.
         The official client reads this if the packet is larger than 6 bytes.
-
-        Note:
-          - Value range is 0-252.
         """
         return self._level_up
 
-    @level_up.setter
-    def level_up(self, level_up: Optional[int]) -> None:
-        """
-        A value greater than 0 is "new level" and indicates the player leveled up.
-        The official client reads this if the packet is larger than 6 bytes.
-
-        Note:
-          - Value range is 0-252.
-        """
-        self._level_up = level_up
-
     @property
     def stat_points(self) -> Optional[int]:
         """
         The official client reads this if the player leveled up
-
-        Note:
-          - Value range is 0-64008.
         """
         return self._stat_points
 
-    @stat_points.setter
-    def stat_points(self, stat_points: Optional[int]) -> None:
-        """
-        The official client reads this if the player leveled up
-
-        Note:
-          - Value range is 0-64008.
-        """
-        self._stat_points = stat_points
-
     @property
     def skill_points(self) -> Optional[int]:
         """
         The official client reads this if the player leveled up
-
-        Note:
-          - Value range is 0-64008.
         """
         return self._skill_points
 
-    @skill_points.setter
-    def skill_points(self, skill_points: Optional[int]) -> None:
-        """
-        The official client reads this if the player leveled up
-
-        Note:
-          - Value range is 0-64008.
-        """
-        self._skill_points = skill_points
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -165,21 +118,25 @@ class RecoverReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (RecoverReplyServerPacket): The data to serialize.
         """
-        if data._experience is None:
-            raise SerializationError("experience must be provided.")
-        writer.add_int(data._experience)
-        if data._karma is None:
-            raise SerializationError("karma must be provided.")
-        writer.add_short(data._karma)
-        reached_missing_optional = data._level_up is None
-        if not reached_missing_optional:
-            writer.add_char(cast(int, data._level_up))
-        reached_missing_optional = reached_missing_optional or data._stat_points is None
-        if not reached_missing_optional:
-            writer.add_short(cast(int, data._stat_points))
-        reached_missing_optional = reached_missing_optional or data._skill_points is None
-        if not reached_missing_optional:
-            writer.add_short(cast(int, data._skill_points))
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._experience is None:
+                raise SerializationError("experience must be provided.")
+            writer.add_int(data._experience)
+            if data._karma is None:
+                raise SerializationError("karma must be provided.")
+            writer.add_short(data._karma)
+            reached_missing_optional = data._level_up is None
+            if not reached_missing_optional:
+                writer.add_char(cast(int, data._level_up))
+            reached_missing_optional = reached_missing_optional or data._stat_points is None
+            if not reached_missing_optional:
+                writer.add_short(cast(int, data._stat_points))
+            reached_missing_optional = reached_missing_optional or data._skill_points is None
+            if not reached_missing_optional:
+                writer.add_short(cast(int, data._skill_points))
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "RecoverReplyServerPacket":
@@ -192,20 +149,23 @@ class RecoverReplyServerPacket(Packet):
         Returns:
             RecoverReplyServerPacket: The data to serialize.
         """
-        data: RecoverReplyServerPacket = RecoverReplyServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._experience = reader.get_int()
-            data._karma = reader.get_short()
+            experience = reader.get_int()
+            karma = reader.get_short()
+            level_up: Optional[int] = None
             if reader.remaining > 0:
-                data._level_up = reader.get_char()
+                level_up = reader.get_char()
+            stat_points: Optional[int] = None
             if reader.remaining > 0:
-                data._stat_points = reader.get_short()
+                stat_points = reader.get_short()
+            skill_points: Optional[int] = None
             if reader.remaining > 0:
-                data._skill_points = reader.get_short()
-            data._byte_size = reader.position - reader_start_position
-            return data
+                skill_points = reader.get_short()
+            result = RecoverReplyServerPacket(experience=experience, karma=karma, level_up=level_up, stat_points=stat_points, skill_points=skill_points)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode