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

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

@@ -15,12 +15,31 @@ class CharacterStatsUpdate:
     Sent when stats are updated.
     """
     _byte_size: int = 0
-    _base_stats: CharacterBaseStats = None # type: ignore [assignment]
-    _max_hp: int = None # type: ignore [assignment]
-    _max_tp: int = None # type: ignore [assignment]
-    _max_sp: int = None # type: ignore [assignment]
-    _max_weight: int = None # type: ignore [assignment]
-    _secondary_stats: CharacterSecondaryStats = None # type: ignore [assignment]
+    _base_stats: CharacterBaseStats
+    _max_hp: int
+    _max_tp: int
+    _max_sp: int
+    _max_weight: int
+    _secondary_stats: CharacterSecondaryStats
+
+    def __init__(self, *, base_stats: CharacterBaseStats, max_hp: int, max_tp: int, max_sp: int, max_weight: int, secondary_stats: CharacterSecondaryStats):
+        """
+        Create a new instance of CharacterStatsUpdate.
+
+        Args:
+            base_stats (CharacterBaseStats): 
+            max_hp (int): (Value range is 0-64008.)
+            max_tp (int): (Value range is 0-64008.)
+            max_sp (int): (Value range is 0-64008.)
+            max_weight (int): (Value range is 0-64008.)
+            secondary_stats (CharacterSecondaryStats): 
+        """
+        self._base_stats = base_stats
+        self._max_hp = max_hp
+        self._max_tp = max_tp
+        self._max_sp = max_sp
+        self._max_weight = max_weight
+        self._secondary_stats = secondary_stats
 
     @property
     def byte_size(self) -> int:
@@ -36,82 +55,26 @@ class CharacterStatsUpdate:
     def base_stats(self) -> CharacterBaseStats:
         return self._base_stats
 
-    @base_stats.setter
-    def base_stats(self, base_stats: CharacterBaseStats) -> None:
-        self._base_stats = base_stats
-
     @property
     def max_hp(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._max_hp
 
-    @max_hp.setter
-    def max_hp(self, max_hp: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._max_hp = max_hp
-
     @property
     def max_tp(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._max_tp
 
-    @max_tp.setter
-    def max_tp(self, max_tp: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._max_tp = max_tp
-
     @property
     def max_sp(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._max_sp
 
-    @max_sp.setter
-    def max_sp(self, max_sp: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._max_sp = max_sp
-
     @property
     def max_weight(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._max_weight
 
-    @max_weight.setter
-    def max_weight(self, max_weight: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._max_weight = max_weight
-
     @property
     def secondary_stats(self) -> CharacterSecondaryStats:
         return self._secondary_stats
 
-    @secondary_stats.setter
-    def secondary_stats(self, secondary_stats: CharacterSecondaryStats) -> None:
-        self._secondary_stats = secondary_stats
-
     @staticmethod
     def serialize(writer: EoWriter, data: "CharacterStatsUpdate") -> None:
         """
@@ -121,24 +84,28 @@ class CharacterStatsUpdate:
             writer (EoWriter): The writer that the data will be serialized to.
             data (CharacterStatsUpdate): The data to serialize.
         """
-        if data._base_stats is None:
-            raise SerializationError("base_stats must be provided.")
-        CharacterBaseStats.serialize(writer, data._base_stats)
-        if data._max_hp is None:
-            raise SerializationError("max_hp must be provided.")
-        writer.add_short(data._max_hp)
-        if data._max_tp is None:
-            raise SerializationError("max_tp must be provided.")
-        writer.add_short(data._max_tp)
-        if data._max_sp is None:
-            raise SerializationError("max_sp must be provided.")
-        writer.add_short(data._max_sp)
-        if data._max_weight is None:
-            raise SerializationError("max_weight must be provided.")
-        writer.add_short(data._max_weight)
-        if data._secondary_stats is None:
-            raise SerializationError("secondary_stats must be provided.")
-        CharacterSecondaryStats.serialize(writer, data._secondary_stats)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._base_stats is None:
+                raise SerializationError("base_stats must be provided.")
+            CharacterBaseStats.serialize(writer, data._base_stats)
+            if data._max_hp is None:
+                raise SerializationError("max_hp must be provided.")
+            writer.add_short(data._max_hp)
+            if data._max_tp is None:
+                raise SerializationError("max_tp must be provided.")
+            writer.add_short(data._max_tp)
+            if data._max_sp is None:
+                raise SerializationError("max_sp must be provided.")
+            writer.add_short(data._max_sp)
+            if data._max_weight is None:
+                raise SerializationError("max_weight must be provided.")
+            writer.add_short(data._max_weight)
+            if data._secondary_stats is None:
+                raise SerializationError("secondary_stats must be provided.")
+            CharacterSecondaryStats.serialize(writer, data._secondary_stats)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CharacterStatsUpdate":
@@ -151,18 +118,18 @@ class CharacterStatsUpdate:
         Returns:
             CharacterStatsUpdate: The data to serialize.
         """
-        data: CharacterStatsUpdate = CharacterStatsUpdate()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._base_stats = CharacterBaseStats.deserialize(reader)
-            data._max_hp = reader.get_short()
-            data._max_tp = reader.get_short()
-            data._max_sp = reader.get_short()
-            data._max_weight = reader.get_short()
-            data._secondary_stats = CharacterSecondaryStats.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            base_stats = CharacterBaseStats.deserialize(reader)
+            max_hp = reader.get_short()
+            max_tp = reader.get_short()
+            max_sp = reader.get_short()
+            max_weight = reader.get_short()
+            secondary_stats = CharacterSecondaryStats.deserialize(reader)
+            result = CharacterStatsUpdate(base_stats=base_stats, max_hp=max_hp, max_tp=max_tp, max_sp=max_sp, max_weight=max_weight, secondary_stats=secondary_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/character_stats_welcome.py

@@ -15,16 +15,43 @@ class CharacterStatsWelcome:
     Sent upon selecting a character and entering the game.
     """
     _byte_size: int = 0
-    _hp: int = None # type: ignore [assignment]
-    _max_hp: int = None # type: ignore [assignment]
-    _tp: int = None # type: ignore [assignment]
-    _max_tp: int = None # type: ignore [assignment]
-    _max_sp: int = None # type: ignore [assignment]
-    _stat_points: int = None # type: ignore [assignment]
-    _skill_points: int = None # type: ignore [assignment]
-    _karma: int = None # type: ignore [assignment]
-    _secondary: CharacterSecondaryStats = None # type: ignore [assignment]
-    _base: CharacterBaseStatsWelcome = None # type: ignore [assignment]
+    _hp: int
+    _max_hp: int
+    _tp: int
+    _max_tp: int
+    _max_sp: int
+    _stat_points: int
+    _skill_points: int
+    _karma: int
+    _secondary: CharacterSecondaryStats
+    _base: CharacterBaseStatsWelcome
+
+    def __init__(self, *, hp: int, max_hp: int, tp: int, max_tp: int, max_sp: int, stat_points: int, skill_points: int, karma: int, secondary: CharacterSecondaryStats, base: CharacterBaseStatsWelcome):
+        """
+        Create a new instance of CharacterStatsWelcome.
+
+        Args:
+            hp (int): (Value range is 0-64008.)
+            max_hp (int): (Value range is 0-64008.)
+            tp (int): (Value range is 0-64008.)
+            max_tp (int): (Value range is 0-64008.)
+            max_sp (int): (Value range is 0-64008.)
+            stat_points (int): (Value range is 0-64008.)
+            skill_points (int): (Value range is 0-64008.)
+            karma (int): (Value range is 0-64008.)
+            secondary (CharacterSecondaryStats): 
+            base (CharacterBaseStatsWelcome): 
+        """
+        self._hp = hp
+        self._max_hp = max_hp
+        self._tp = tp
+        self._max_tp = max_tp
+        self._max_sp = max_sp
+        self._stat_points = stat_points
+        self._skill_points = skill_points
+        self._karma = karma
+        self._secondary = secondary
+        self._base = base
 
     @property
     def byte_size(self) -> int:
@@ -38,148 +65,44 @@ class CharacterStatsWelcome:
 
     @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 max_hp(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._max_hp
 
-    @max_hp.setter
-    def max_hp(self, max_hp: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._max_hp = max_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
-
     @property
     def max_tp(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._max_tp
 
-    @max_tp.setter
-    def max_tp(self, max_tp: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._max_tp = max_tp
-
     @property
     def max_sp(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._max_sp
 
-    @max_sp.setter
-    def max_sp(self, max_sp: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._max_sp = max_sp
-
     @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 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 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 secondary(self) -> CharacterSecondaryStats:
         return self._secondary
 
-    @secondary.setter
-    def secondary(self, secondary: CharacterSecondaryStats) -> None:
-        self._secondary = secondary
-
     @property
     def base(self) -> CharacterBaseStatsWelcome:
         return self._base
 
-    @base.setter
-    def base(self, base: CharacterBaseStatsWelcome) -> None:
-        self._base = base
-
     @staticmethod
     def serialize(writer: EoWriter, data: "CharacterStatsWelcome") -> None:
         """
@@ -189,36 +112,40 @@ class CharacterStatsWelcome:
             writer (EoWriter): The writer that the data will be serialized to.
             data (CharacterStatsWelcome): The data to serialize.
         """
-        if data._hp is None:
-            raise SerializationError("hp must be provided.")
-        writer.add_short(data._hp)
-        if data._max_hp is None:
-            raise SerializationError("max_hp must be provided.")
-        writer.add_short(data._max_hp)
-        if data._tp is None:
-            raise SerializationError("tp must be provided.")
-        writer.add_short(data._tp)
-        if data._max_tp is None:
-            raise SerializationError("max_tp must be provided.")
-        writer.add_short(data._max_tp)
-        if data._max_sp is None:
-            raise SerializationError("max_sp must be provided.")
-        writer.add_short(data._max_sp)
-        if data._stat_points is None:
-            raise SerializationError("stat_points must be provided.")
-        writer.add_short(data._stat_points)
-        if data._skill_points is None:
-            raise SerializationError("skill_points must be provided.")
-        writer.add_short(data._skill_points)
-        if data._karma is None:
-            raise SerializationError("karma must be provided.")
-        writer.add_short(data._karma)
-        if data._secondary is None:
-            raise SerializationError("secondary must be provided.")
-        CharacterSecondaryStats.serialize(writer, data._secondary)
-        if data._base is None:
-            raise SerializationError("base must be provided.")
-        CharacterBaseStatsWelcome.serialize(writer, data._base)
+        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._max_hp is None:
+                raise SerializationError("max_hp must be provided.")
+            writer.add_short(data._max_hp)
+            if data._tp is None:
+                raise SerializationError("tp must be provided.")
+            writer.add_short(data._tp)
+            if data._max_tp is None:
+                raise SerializationError("max_tp must be provided.")
+            writer.add_short(data._max_tp)
+            if data._max_sp is None:
+                raise SerializationError("max_sp must be provided.")
+            writer.add_short(data._max_sp)
+            if data._stat_points is None:
+                raise SerializationError("stat_points must be provided.")
+            writer.add_short(data._stat_points)
+            if data._skill_points is None:
+                raise SerializationError("skill_points must be provided.")
+            writer.add_short(data._skill_points)
+            if data._karma is None:
+                raise SerializationError("karma must be provided.")
+            writer.add_short(data._karma)
+            if data._secondary is None:
+                raise SerializationError("secondary must be provided.")
+            CharacterSecondaryStats.serialize(writer, data._secondary)
+            if data._base is None:
+                raise SerializationError("base must be provided.")
+            CharacterBaseStatsWelcome.serialize(writer, data._base)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CharacterStatsWelcome":
@@ -231,22 +158,22 @@ class CharacterStatsWelcome:
         Returns:
             CharacterStatsWelcome: The data to serialize.
         """
-        data: CharacterStatsWelcome = CharacterStatsWelcome()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._hp = reader.get_short()
-            data._max_hp = reader.get_short()
-            data._tp = reader.get_short()
-            data._max_tp = reader.get_short()
-            data._max_sp = reader.get_short()
-            data._stat_points = reader.get_short()
-            data._skill_points = reader.get_short()
-            data._karma = reader.get_short()
-            data._secondary = CharacterSecondaryStats.deserialize(reader)
-            data._base = CharacterBaseStatsWelcome.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            hp = reader.get_short()
+            max_hp = reader.get_short()
+            tp = reader.get_short()
+            max_tp = reader.get_short()
+            max_sp = reader.get_short()
+            stat_points = reader.get_short()
+            skill_points = reader.get_short()
+            karma = reader.get_short()
+            secondary = CharacterSecondaryStats.deserialize(reader)
+            base = CharacterBaseStatsWelcome.deserialize(reader)
+            result = CharacterStatsWelcome(hp=hp, max_hp=max_hp, tp=tp, max_tp=max_tp, max_sp=max_sp, stat_points=stat_points, skill_points=skill_points, karma=karma, secondary=secondary, base=base)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/net/server/chest_agree_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
@@ -17,7 +18,16 @@ class ChestAgreeServerPacket(Packet):
     Chest contents updating
     """
     _byte_size: int = 0
-    _items: list[ThreeItem] = None # type: ignore [assignment]
+    _items: tuple[ThreeItem, ...]
+
+    def __init__(self, *, items: Iterable[ThreeItem]):
+        """
+        Create a new instance of ChestAgreeServerPacket.
+
+        Args:
+            items (Iterable[ThreeItem]): 
+        """
+        self._items = tuple(items)
 
     @property
     def byte_size(self) -> int:
@@ -30,13 +40,9 @@ class ChestAgreeServerPacket(Packet):
         return self._byte_size
 
     @property
-    def items(self) -> list[ThreeItem]:
+    def items(self) -> tuple[ThreeItem, ...]:
         return self._items
 
-    @items.setter
-    def items(self, items: list[ThreeItem]) -> None:
-        self._items = items
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -75,10 +81,14 @@ class ChestAgreeServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ChestAgreeServerPacket): The data to serialize.
         """
-        if data._items is None:
-            raise SerializationError("items must be provided.")
-        for i in range(len(data._items)):
-            ThreeItem.serialize(writer, data._items[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._items is None:
+                raise SerializationError("items must be provided.")
+            for i in range(len(data._items)):
+                ThreeItem.serialize(writer, data._items[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ChestAgreeServerPacket":
@@ -91,16 +101,16 @@ class ChestAgreeServerPacket(Packet):
         Returns:
             ChestAgreeServerPacket: The data to serialize.
         """
-        data: ChestAgreeServerPacket = ChestAgreeServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             items_length = int(reader.remaining / 5)
-            data._items = []
+            items = []
             for i in range(items_length):
-                data._items.append(ThreeItem.deserialize(reader))
-            data._byte_size = reader.position - reader_start_position
-            return data
+                items.append(ThreeItem.deserialize(reader))
+            result = ChestAgreeServerPacket(items=items)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -13,11 +13,20 @@ from .....data.eo_reader import EoReader
 
 class ChestCloseServerPacket(Packet):
     """
-    Reply to trying to interact with a locked or "broken" chest.
+    Reply to trying to interact with a locked or "broken" chest.
     The official client assumes a broken chest if the packet is under 2 bytes in length.
     """
     _byte_size: int = 0
-    _key: Optional[int] = None # type: ignore [assignment]
+    _key: Optional[int]
+
+    def __init__(self, *, key: Optional[int] = None):
+        """
+        Create a new instance of ChestCloseServerPacket.
+
+        Args:
+            key (Optional[int]): Sent if the player is trying to interact with a locked chest (Value range is 0-64008.)
+        """
+        self._key = key
 
     @property
     def byte_size(self) -> int:
@@ -33,22 +42,9 @@ class ChestCloseServerPacket(Packet):
     def key(self) -> Optional[int]:
         """
         Sent if the player is trying to interact with a locked chest
-
-        Note:
-          - Value range is 0-64008.
         """
         return self._key
 
-    @key.setter
-    def key(self, key: Optional[int]) -> None:
-        """
-        Sent if the player is trying to interact with a locked chest
-
-        Note:
-          - Value range is 0-64008.
-        """
-        self._key = key
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -87,10 +83,16 @@ class ChestCloseServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ChestCloseServerPacket): The data to serialize.
         """
-        reached_missing_optional = data._key is None
-        if not reached_missing_optional:
-            writer.add_short(cast(int, data._key))
-        writer.add_string("N")
+        old_writer_length: int = len(writer)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            reached_missing_optional = data._key is None
+            if not reached_missing_optional:
+                writer.add_short(cast(int, data._key))
+            if len(writer) == old_writer_length:
+                writer.add_string("N")
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ChestCloseServerPacket":
@@ -103,15 +105,17 @@ class ChestCloseServerPacket(Packet):
         Returns:
             ChestCloseServerPacket: The data to serialize.
         """
-        data: ChestCloseServerPacket = ChestCloseServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
+            key: Optional[int] = None
             if reader.remaining > 0:
-                data._key = reader.get_short()
-            reader.get_string()
-            data._byte_size = reader.position - reader_start_position
-            return data
+                key = reader.get_short()
+            if reader.position == reader_start_position:
+                reader.get_string()
+            result = ChestCloseServerPacket(key=key)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode