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

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

@@ -17,12 +17,31 @@ class SpellTargetSelfServerPacket(Packet):
     Nearby player self-casted a spell
     """
     _byte_size: int = 0
-    _player_id: int = None # type: ignore [assignment]
-    _spell_id: int = None # type: ignore [assignment]
-    _spell_heal_hp: int = None # type: ignore [assignment]
-    _hp_percentage: int = None # type: ignore [assignment]
-    _hp: Optional[int] = None # type: ignore [assignment]
-    _tp: Optional[int] = None # type: ignore [assignment]
+    _player_id: int
+    _spell_id: int
+    _spell_heal_hp: int
+    _hp_percentage: int
+    _hp: Optional[int]
+    _tp: Optional[int]
+
+    def __init__(self, *, player_id: int, spell_id: int, spell_heal_hp: int, hp_percentage: int, hp: Optional[int] = None, tp: Optional[int] = None):
+        """
+        Create a new instance of SpellTargetSelfServerPacket.
+
+        Args:
+            player_id (int): (Value range is 0-64008.)
+            spell_id (int): (Value range is 0-64008.)
+            spell_heal_hp (int): (Value range is 0-4097152080.)
+            hp_percentage (int): (Value range is 0-252.)
+            hp (Optional[int]): The official client reads this if the packet is larger than 12 bytes (Value range is 0-64008.)
+            tp (Optional[int]): The official client reads this if the packet is larger than 12 bytes (Value range is 0-64008.)
+        """
+        self._player_id = player_id
+        self._spell_id = spell_id
+        self._spell_heal_hp = spell_heal_hp
+        self._hp_percentage = hp_percentage
+        self._hp = hp
+        self._tp = tp
 
     @property
     def byte_size(self) -> int:
@@ -36,108 +55,34 @@ class SpellTargetSelfServerPacket(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 spell_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._spell_id
 
-    @spell_id.setter
-    def spell_id(self, spell_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._spell_id = spell_id
-
     @property
     def spell_heal_hp(self) -> int:
-        """
-        Note:
-          - Value range is 0-4097152080.
-        """
         return self._spell_heal_hp
 
-    @spell_heal_hp.setter
-    def spell_heal_hp(self, spell_heal_hp: int) -> None:
-        """
-        Note:
-          - Value range is 0-4097152080.
-        """
-        self._spell_heal_hp = spell_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
-
     @property
     def hp(self) -> Optional[int]:
         """
         The official client reads this if the packet is larger than 12 bytes
-
-        Note:
-          - Value range is 0-64008.
         """
         return self._hp
 
-    @hp.setter
-    def hp(self, hp: Optional[int]) -> None:
-        """
-        The official client reads this if the packet is larger than 12 bytes
-
-        Note:
-          - Value range is 0-64008.
-        """
-        self._hp = hp
-
     @property
     def tp(self) -> Optional[int]:
         """
         The official client reads this if the packet is larger than 12 bytes
-
-        Note:
-          - Value range is 0-64008.
         """
         return self._tp
 
-    @tp.setter
-    def tp(self, tp: Optional[int]) -> None:
-        """
-        The official client reads this if the packet is larger than 12 bytes
-
-        Note:
-          - Value range is 0-64008.
-        """
-        self._tp = tp
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -176,24 +121,28 @@ class SpellTargetSelfServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellTargetSelfServerPacket): 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._spell_id is None:
-            raise SerializationError("spell_id must be provided.")
-        writer.add_short(data._spell_id)
-        if data._spell_heal_hp is None:
-            raise SerializationError("spell_heal_hp must be provided.")
-        writer.add_int(data._spell_heal_hp)
-        if data._hp_percentage is None:
-            raise SerializationError("hp_percentage must be provided.")
-        writer.add_char(data._hp_percentage)
-        reached_missing_optional = data._hp is None
-        if not reached_missing_optional:
-            writer.add_short(cast(int, data._hp))
-        reached_missing_optional = reached_missing_optional or data._tp is None
-        if not reached_missing_optional:
-            writer.add_short(cast(int, data._tp))
+        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._spell_id is None:
+                raise SerializationError("spell_id must be provided.")
+            writer.add_short(data._spell_id)
+            if data._spell_heal_hp is None:
+                raise SerializationError("spell_heal_hp must be provided.")
+            writer.add_int(data._spell_heal_hp)
+            if data._hp_percentage is None:
+                raise SerializationError("hp_percentage must be provided.")
+            writer.add_char(data._hp_percentage)
+            reached_missing_optional = data._hp is None
+            if not reached_missing_optional:
+                writer.add_short(cast(int, data._hp))
+            reached_missing_optional = reached_missing_optional or data._tp is None
+            if not reached_missing_optional:
+                writer.add_short(cast(int, data._tp))
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SpellTargetSelfServerPacket":
@@ -206,20 +155,22 @@ class SpellTargetSelfServerPacket(Packet):
         Returns:
             SpellTargetSelfServerPacket: The data to serialize.
         """
-        data: SpellTargetSelfServerPacket = SpellTargetSelfServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._player_id = reader.get_short()
-            data._spell_id = reader.get_short()
-            data._spell_heal_hp = reader.get_int()
-            data._hp_percentage = reader.get_char()
+            player_id = reader.get_short()
+            spell_id = reader.get_short()
+            spell_heal_hp = reader.get_int()
+            hp_percentage = reader.get_char()
+            hp: Optional[int] = None
             if reader.remaining > 0:
-                data._hp = reader.get_short()
+                hp = reader.get_short()
+            tp: Optional[int] = None
             if reader.remaining > 0:
-                data._tp = reader.get_short()
-            data._byte_size = reader.position - reader_start_position
-            return data
+                tp = reader.get_short()
+            result = SpellTargetSelfServerPacket(player_id=player_id, spell_id=spell_id, spell_heal_hp=spell_heal_hp, hp_percentage=hp_percentage, 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/stat_skill_accept_server_packet.py

@@ -16,8 +16,19 @@ class StatSkillAcceptServerPacket(Packet):
     Response to spending skill points
     """
     _byte_size: int = 0
-    _skill_points: int = None # type: ignore [assignment]
-    _spell: Spell = None # type: ignore [assignment]
+    _skill_points: int
+    _spell: Spell
+
+    def __init__(self, *, skill_points: int, spell: Spell):
+        """
+        Create a new instance of StatSkillAcceptServerPacket.
+
+        Args:
+            skill_points (int): (Value range is 0-64008.)
+            spell (Spell): 
+        """
+        self._skill_points = skill_points
+        self._spell = spell
 
     @property
     def byte_size(self) -> int:
@@ -31,28 +42,12 @@ class StatSkillAcceptServerPacket(Packet):
 
     @property
     def skill_points(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._skill_points
 
-    @skill_points.setter
-    def skill_points(self, skill_points: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._skill_points = skill_points
-
     @property
     def spell(self) -> Spell:
         return self._spell
 
-    @spell.setter
-    def spell(self, spell: Spell) -> None:
-        self._spell = spell
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -91,12 +86,16 @@ class StatSkillAcceptServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (StatSkillAcceptServerPacket): The data to serialize.
         """
-        if data._skill_points is None:
-            raise SerializationError("skill_points must be provided.")
-        writer.add_short(data._skill_points)
-        if data._spell is None:
-            raise SerializationError("spell must be provided.")
-        Spell.serialize(writer, data._spell)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._skill_points is None:
+                raise SerializationError("skill_points must be provided.")
+            writer.add_short(data._skill_points)
+            if data._spell is None:
+                raise SerializationError("spell must be provided.")
+            Spell.serialize(writer, data._spell)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "StatSkillAcceptServerPacket":
@@ -109,14 +108,14 @@ class StatSkillAcceptServerPacket(Packet):
         Returns:
             StatSkillAcceptServerPacket: The data to serialize.
         """
-        data: StatSkillAcceptServerPacket = StatSkillAcceptServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._skill_points = reader.get_short()
-            data._spell = Spell.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            skill_points = reader.get_short()
+            spell = Spell.deserialize(reader)
+            result = StatSkillAcceptServerPacket(skill_points=skill_points, spell=spell)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -16,7 +16,16 @@ class StatSkillJunkServerPacket(Packet):
     Response to resetting stats and skills at a skill master
     """
     _byte_size: int = 0
-    _stats: CharacterStatsReset = None # type: ignore [assignment]
+    _stats: CharacterStatsReset
+
+    def __init__(self, *, stats: CharacterStatsReset):
+        """
+        Create a new instance of StatSkillJunkServerPacket.
+
+        Args:
+            stats (CharacterStatsReset): 
+        """
+        self._stats = stats
 
     @property
     def byte_size(self) -> int:
@@ -32,10 +41,6 @@ class StatSkillJunkServerPacket(Packet):
     def stats(self) -> CharacterStatsReset:
         return self._stats
 
-    @stats.setter
-    def stats(self, stats: CharacterStatsReset) -> None:
-        self._stats = stats
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -74,9 +79,13 @@ class StatSkillJunkServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (StatSkillJunkServerPacket): The data to serialize.
         """
-        if data._stats is None:
-            raise SerializationError("stats must be provided.")
-        CharacterStatsReset.serialize(writer, data._stats)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._stats is None:
+                raise SerializationError("stats must be provided.")
+            CharacterStatsReset.serialize(writer, data._stats)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "StatSkillJunkServerPacket":
@@ -89,13 +98,13 @@ class StatSkillJunkServerPacket(Packet):
         Returns:
             StatSkillJunkServerPacket: The data to serialize.
         """
-        data: StatSkillJunkServerPacket = StatSkillJunkServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._stats = CharacterStatsReset.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            stats = CharacterStatsReset.deserialize(reader)
+            result = StatSkillJunkServerPacket(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/stat_skill_open_server_packet.py

@@ -4,6 +4,7 @@
 # Changes will be lost when code is regenerated.
 
 from __future__ import annotations
+from collections.abc import Iterable
 from .skill_learn import SkillLearn
 from ..packet_family import PacketFamily
 from ..packet_action import PacketAction
@@ -17,9 +18,22 @@ class StatSkillOpenServerPacket(Packet):
     Response from talking to a skill master NPC
     """
     _byte_size: int = 0
-    _session_id: int = None # type: ignore [assignment]
-    _shop_name: str = None # type: ignore [assignment]
-    _skills: list[SkillLearn] = None # type: ignore [assignment]
+    _session_id: int
+    _shop_name: str
+    _skills: tuple[SkillLearn, ...]
+
+    def __init__(self, *, session_id: int, shop_name: str, skills: Iterable[SkillLearn]):
+        """
+        Create a new instance of StatSkillOpenServerPacket.
+
+        Args:
+            session_id (int): (Value range is 0-64008.)
+            shop_name (str): 
+            skills (Iterable[SkillLearn]): 
+        """
+        self._session_id = session_id
+        self._shop_name = shop_name
+        self._skills = tuple(skills)
 
     @property
     def byte_size(self) -> int:
@@ -33,36 +47,16 @@ class StatSkillOpenServerPacket(Packet):
 
     @property
     def session_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._session_id
 
-    @session_id.setter
-    def session_id(self, session_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._session_id = session_id
-
     @property
     def shop_name(self) -> str:
         return self._shop_name
 
-    @shop_name.setter
-    def shop_name(self, shop_name: str) -> None:
-        self._shop_name = shop_name
-
     @property
-    def skills(self) -> list[SkillLearn]:
+    def skills(self) -> tuple[SkillLearn, ...]:
         return self._skills
 
-    @skills.setter
-    def skills(self, skills: list[SkillLearn]) -> None:
-        self._skills = skills
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -101,17 +95,23 @@ class StatSkillOpenServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (StatSkillOpenServerPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_short(data._session_id)
-        if data._shop_name is None:
-            raise SerializationError("shop_name must be provided.")
-        writer.add_string(data._shop_name)
-        writer.add_byte(0xFF)
-        if data._skills is None:
-            raise SerializationError("skills must be provided.")
-        for i in range(len(data._skills)):
-            SkillLearn.serialize(writer, data._skills[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_short(data._session_id)
+            if data._shop_name is None:
+                raise SerializationError("shop_name must be provided.")
+            writer.add_string(data._shop_name)
+            writer.add_byte(0xFF)
+            if data._skills is None:
+                raise SerializationError("skills must be provided.")
+            for i in range(len(data._skills)):
+                SkillLearn.serialize(writer, data._skills[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "StatSkillOpenServerPacket":
@@ -124,21 +124,21 @@ class StatSkillOpenServerPacket(Packet):
         Returns:
             StatSkillOpenServerPacket: The data to serialize.
         """
-        data: StatSkillOpenServerPacket = StatSkillOpenServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
-            data._session_id = reader.get_short()
-            data._shop_name = reader.get_string()
+            session_id = reader.get_short()
+            shop_name = reader.get_string()
             reader.next_chunk()
             skills_length = int(reader.remaining / 28)
-            data._skills = []
+            skills = []
             for i in range(skills_length):
-                data._skills.append(SkillLearn.deserialize(reader))
+                skills.append(SkillLearn.deserialize(reader))
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = StatSkillOpenServerPacket(session_id=session_id, shop_name=shop_name, skills=skills)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -16,8 +16,19 @@ class StatSkillPlayerServerPacket(Packet):
     Response to spending stat points
     """
     _byte_size: int = 0
-    _stat_points: int = None # type: ignore [assignment]
-    _stats: CharacterStatsUpdate = None # type: ignore [assignment]
+    _stat_points: int
+    _stats: CharacterStatsUpdate
+
+    def __init__(self, *, stat_points: int, stats: CharacterStatsUpdate):
+        """
+        Create a new instance of StatSkillPlayerServerPacket.
+
+        Args:
+            stat_points (int): (Value range is 0-64008.)
+            stats (CharacterStatsUpdate): 
+        """
+        self._stat_points = stat_points
+        self._stats = stats
 
     @property
     def byte_size(self) -> int:
@@ -31,28 +42,12 @@ class StatSkillPlayerServerPacket(Packet):
 
     @property
     def stat_points(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._stat_points
 
-    @stat_points.setter
-    def stat_points(self, stat_points: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._stat_points = stat_points
-
     @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 StatSkillPlayerServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (StatSkillPlayerServerPacket): The data to serialize.
         """
-        if data._stat_points is None:
-            raise SerializationError("stat_points must be provided.")
-        writer.add_short(data._stat_points)
-        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._stat_points is None:
+                raise SerializationError("stat_points must be provided.")
+            writer.add_short(data._stat_points)
+            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) -> "StatSkillPlayerServerPacket":
@@ -109,14 +108,14 @@ class StatSkillPlayerServerPacket(Packet):
         Returns:
             StatSkillPlayerServerPacket: The data to serialize.
         """
-        data: StatSkillPlayerServerPacket = StatSkillPlayerServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._stat_points = reader.get_short()
-            data._stats = CharacterStatsUpdate.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            stat_points = reader.get_short()
+            stats = CharacterStatsUpdate.deserialize(reader)
+            result = StatSkillPlayerServerPacket(stat_points=stat_points, stats=stats)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode