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

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

@@ -20,10 +20,25 @@ class ItemReplyServerPacket(Packet):
     Reply to using an item
     """
     _byte_size: int = 0
-    _item_type: ItemType = None # type: ignore [assignment]
-    _used_item: Item = None # type: ignore [assignment]
-    _weight: Weight = None # type: ignore [assignment]
-    _item_type_data: 'ItemReplyServerPacket.ItemTypeData' = None
+    _item_type: ItemType
+    _used_item: Item
+    _weight: Weight
+    _item_type_data: 'ItemReplyServerPacket.ItemTypeData'
+
+    def __init__(self, *, item_type: ItemType, used_item: Item, weight: Weight, item_type_data: 'ItemReplyServerPacket.ItemTypeData' = None):
+        """
+        Create a new instance of ItemReplyServerPacket.
+
+        Args:
+            item_type (ItemType): 
+            used_item (Item): 
+            weight (Weight): 
+            item_type_data (ItemReplyServerPacket.ItemTypeData): Data associated with the `item_type` field.
+        """
+        self._item_type = item_type
+        self._used_item = used_item
+        self._weight = weight
+        self._item_type_data = item_type_data
 
     @property
     def byte_size(self) -> int:
@@ -39,37 +54,21 @@ class ItemReplyServerPacket(Packet):
     def item_type(self) -> ItemType:
         return self._item_type
 
-    @item_type.setter
-    def item_type(self, item_type: ItemType) -> None:
-        self._item_type = item_type
-
     @property
     def used_item(self) -> Item:
         return self._used_item
 
-    @used_item.setter
-    def used_item(self, used_item: Item) -> None:
-        self._used_item = used_item
-
     @property
     def weight(self) -> Weight:
         return self._weight
 
-    @weight.setter
-    def weight(self, weight: Weight) -> None:
-        self._weight = weight
-
     @property
     def item_type_data(self) -> 'ItemReplyServerPacket.ItemTypeData':
         """
-        ItemReplyServerPacket.ItemTypeData: Gets or sets the data associated with the `item_type` field.
+        ItemReplyServerPacket.ItemTypeData: Data associated with the `item_type` field.
         """
         return self._item_type_data
 
-    @item_type_data.setter
-    def item_type_data(self, item_type_data: 'ItemReplyServerPacket.ItemTypeData') -> None:
-        self._item_type_data = item_type_data
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -153,25 +152,26 @@ class ItemReplyServerPacket(Packet):
         Returns:
             ItemReplyServerPacket: The data to serialize.
         """
-        data: ItemReplyServerPacket = ItemReplyServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._item_type = ItemType(reader.get_char())
-            data._used_item = Item.deserialize(reader)
-            data._weight = Weight.deserialize(reader)
-            if data._item_type == ItemType.Heal:
-                data._item_type_data = ItemReplyServerPacket.ItemTypeDataHeal.deserialize(reader)
-            elif data._item_type == ItemType.HairDye:
-                data._item_type_data = ItemReplyServerPacket.ItemTypeDataHairDye.deserialize(reader)
-            elif data._item_type == ItemType.EffectPotion:
-                data._item_type_data = ItemReplyServerPacket.ItemTypeDataEffectPotion.deserialize(reader)
-            elif data._item_type == ItemType.CureCurse:
-                data._item_type_data = ItemReplyServerPacket.ItemTypeDataCureCurse.deserialize(reader)
-            elif data._item_type == ItemType.ExpReward:
-                data._item_type_data = ItemReplyServerPacket.ItemTypeDataExpReward.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            item_type = ItemType(reader.get_char())
+            used_item = Item.deserialize(reader)
+            weight = Weight.deserialize(reader)
+            item_type_data: ItemReplyServerPacket.ItemTypeData = None
+            if item_type == ItemType.Heal:
+                item_type_data = ItemReplyServerPacket.ItemTypeDataHeal.deserialize(reader)
+            elif item_type == ItemType.HairDye:
+                item_type_data = ItemReplyServerPacket.ItemTypeDataHairDye.deserialize(reader)
+            elif item_type == ItemType.EffectPotion:
+                item_type_data = ItemReplyServerPacket.ItemTypeDataEffectPotion.deserialize(reader)
+            elif item_type == ItemType.CureCurse:
+                item_type_data = ItemReplyServerPacket.ItemTypeDataCureCurse.deserialize(reader)
+            elif item_type == ItemType.ExpReward:
+                item_type_data = ItemReplyServerPacket.ItemTypeDataExpReward.deserialize(reader)
+            result = ItemReplyServerPacket(item_type=item_type, used_item=used_item, weight=weight, item_type_data=item_type_data)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -188,9 +188,22 @@ class ItemReplyServerPacket(Packet):
         Data associated with item_type value ItemType.Heal
         """
         _byte_size: int = 0
-        _hp_gain: int = None # type: ignore [assignment]
-        _hp: int = None # type: ignore [assignment]
-        _tp: int = None # type: ignore [assignment]
+        _hp_gain: int
+        _hp: int
+        _tp: int
+
+        def __init__(self, *, hp_gain: int, hp: int, tp: int):
+            """
+            Create a new instance of ItemReplyServerPacket.ItemTypeDataHeal.
+
+            Args:
+                hp_gain (int): (Value range is 0-4097152080.)
+                hp (int): (Value range is 0-64008.)
+                tp (int): (Value range is 0-64008.)
+            """
+            self._hp_gain = hp_gain
+            self._hp = hp
+            self._tp = tp
 
         @property
         def byte_size(self) -> int:
@@ -204,52 +217,16 @@ class ItemReplyServerPacket(Packet):
 
         @property
         def hp_gain(self) -> int:
-            """
-            Note:
-              - Value range is 0-4097152080.
-            """
             return self._hp_gain
 
-        @hp_gain.setter
-        def hp_gain(self, hp_gain: int) -> None:
-            """
-            Note:
-              - Value range is 0-4097152080.
-            """
-            self._hp_gain = hp_gain
-
         @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 serialize(writer: EoWriter, data: "ItemReplyServerPacket.ItemTypeDataHeal") -> None:
             """
@@ -284,15 +261,15 @@ class ItemReplyServerPacket(Packet):
             Returns:
                 ItemReplyServerPacket.ItemTypeDataHeal: The data to serialize.
             """
-            data: ItemReplyServerPacket.ItemTypeDataHeal = ItemReplyServerPacket.ItemTypeDataHeal()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._hp_gain = reader.get_int()
-                data._hp = reader.get_short()
-                data._tp = reader.get_short()
-                data._byte_size = reader.position - reader_start_position
-                return data
+                hp_gain = reader.get_int()
+                hp = reader.get_short()
+                tp = reader.get_short()
+                result = ItemReplyServerPacket.ItemTypeDataHeal(hp_gain=hp_gain, hp=hp, tp=tp)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -304,7 +281,16 @@ class ItemReplyServerPacket(Packet):
         Data associated with item_type value ItemType.HairDye
         """
         _byte_size: int = 0
-        _hair_color: int = None # type: ignore [assignment]
+        _hair_color: int
+
+        def __init__(self, *, hair_color: int):
+            """
+            Create a new instance of ItemReplyServerPacket.ItemTypeDataHairDye.
+
+            Args:
+                hair_color (int): (Value range is 0-252.)
+            """
+            self._hair_color = hair_color
 
         @property
         def byte_size(self) -> int:
@@ -318,20 +304,8 @@ class ItemReplyServerPacket(Packet):
 
         @property
         def hair_color(self) -> int:
-            """
-            Note:
-              - Value range is 0-252.
-            """
             return self._hair_color
 
-        @hair_color.setter
-        def hair_color(self, hair_color: int) -> None:
-            """
-            Note:
-              - Value range is 0-252.
-            """
-            self._hair_color = hair_color
-
         @staticmethod
         def serialize(writer: EoWriter, data: "ItemReplyServerPacket.ItemTypeDataHairDye") -> None:
             """
@@ -360,13 +334,13 @@ class ItemReplyServerPacket(Packet):
             Returns:
                 ItemReplyServerPacket.ItemTypeDataHairDye: The data to serialize.
             """
-            data: ItemReplyServerPacket.ItemTypeDataHairDye = ItemReplyServerPacket.ItemTypeDataHairDye()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._hair_color = reader.get_char()
-                data._byte_size = reader.position - reader_start_position
-                return data
+                hair_color = reader.get_char()
+                result = ItemReplyServerPacket.ItemTypeDataHairDye(hair_color=hair_color)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -378,7 +352,16 @@ class ItemReplyServerPacket(Packet):
         Data associated with item_type value ItemType.EffectPotion
         """
         _byte_size: int = 0
-        _effect_id: int = None # type: ignore [assignment]
+        _effect_id: int
+
+        def __init__(self, *, effect_id: int):
+            """
+            Create a new instance of ItemReplyServerPacket.ItemTypeDataEffectPotion.
+
+            Args:
+                effect_id (int): (Value range is 0-64008.)
+            """
+            self._effect_id = effect_id
 
         @property
         def byte_size(self) -> int:
@@ -392,20 +375,8 @@ class ItemReplyServerPacket(Packet):
 
         @property
         def effect_id(self) -> int:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
             return self._effect_id
 
-        @effect_id.setter
-        def effect_id(self, effect_id: int) -> None:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
-            self._effect_id = effect_id
-
         @staticmethod
         def serialize(writer: EoWriter, data: "ItemReplyServerPacket.ItemTypeDataEffectPotion") -> None:
             """
@@ -434,13 +405,13 @@ class ItemReplyServerPacket(Packet):
             Returns:
                 ItemReplyServerPacket.ItemTypeDataEffectPotion: The data to serialize.
             """
-            data: ItemReplyServerPacket.ItemTypeDataEffectPotion = ItemReplyServerPacket.ItemTypeDataEffectPotion()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._effect_id = reader.get_short()
-                data._byte_size = reader.position - reader_start_position
-                return data
+                effect_id = reader.get_short()
+                result = ItemReplyServerPacket.ItemTypeDataEffectPotion(effect_id=effect_id)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -452,7 +423,16 @@ class ItemReplyServerPacket(Packet):
         Data associated with item_type value ItemType.CureCurse
         """
         _byte_size: int = 0
-        _stats: CharacterStatsEquipmentChange = None # type: ignore [assignment]
+        _stats: CharacterStatsEquipmentChange
+
+        def __init__(self, *, stats: CharacterStatsEquipmentChange):
+            """
+            Create a new instance of ItemReplyServerPacket.ItemTypeDataCureCurse.
+
+            Args:
+                stats (CharacterStatsEquipmentChange): 
+            """
+            self._stats = stats
 
         @property
         def byte_size(self) -> int:
@@ -468,10 +448,6 @@ class ItemReplyServerPacket(Packet):
         def stats(self) -> CharacterStatsEquipmentChange:
             return self._stats
 
-        @stats.setter
-        def stats(self, stats: CharacterStatsEquipmentChange) -> None:
-            self._stats = stats
-
         @staticmethod
         def serialize(writer: EoWriter, data: "ItemReplyServerPacket.ItemTypeDataCureCurse") -> None:
             """
@@ -500,13 +476,13 @@ class ItemReplyServerPacket(Packet):
             Returns:
                 ItemReplyServerPacket.ItemTypeDataCureCurse: The data to serialize.
             """
-            data: ItemReplyServerPacket.ItemTypeDataCureCurse = ItemReplyServerPacket.ItemTypeDataCureCurse()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._stats = CharacterStatsEquipmentChange.deserialize(reader)
-                data._byte_size = reader.position - reader_start_position
-                return data
+                stats = CharacterStatsEquipmentChange.deserialize(reader)
+                result = ItemReplyServerPacket.ItemTypeDataCureCurse(stats=stats)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -518,13 +494,34 @@ class ItemReplyServerPacket(Packet):
         Data associated with item_type value ItemType.ExpReward
         """
         _byte_size: int = 0
-        _experience: int = None # type: ignore [assignment]
-        _level_up: int = None # type: ignore [assignment]
-        _stat_points: int = None # type: ignore [assignment]
-        _skill_points: int = 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]
+        _experience: int
+        _level_up: int
+        _stat_points: int
+        _skill_points: int
+        _max_hp: int
+        _max_tp: int
+        _max_sp: int
+
+        def __init__(self, *, experience: int, level_up: int, stat_points: int, skill_points: int, max_hp: int, max_tp: int, max_sp: int):
+            """
+            Create a new instance of ItemReplyServerPacket.ItemTypeDataExpReward.
+
+            Args:
+                experience (int): (Value range is 0-4097152080.)
+                level_up (int): A value greater than 0 is "new level" and indicates the player leveled up. (Value range is 0-252.)
+                stat_points (int): (Value range is 0-64008.)
+                skill_points (int): (Value range is 0-64008.)
+                max_hp (int): (Value range is 0-64008.)
+                max_tp (int): (Value range is 0-64008.)
+                max_sp (int): (Value range is 0-64008.)
+            """
+            self._experience = experience
+            self._level_up = level_up
+            self._stat_points = stat_points
+            self._skill_points = skill_points
+            self._max_hp = max_hp
+            self._max_tp = max_tp
+            self._max_sp = max_sp
 
         @property
         def byte_size(self) -> int:
@@ -538,120 +535,35 @@ class ItemReplyServerPacket(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 level_up(self) -> int:
             """
             A value greater than 0 is "new level" and indicates the player leveled up.
-
-            Note:
-              - Value range is 0-252.
             """
             return self._level_up
 
-        @level_up.setter
-        def level_up(self, level_up: int) -> None:
-            """
-            A value greater than 0 is "new level" and indicates the player leveled up.
-
-            Note:
-              - Value range is 0-252.
-            """
-            self._level_up = level_up
-
         @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 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
-
         @staticmethod
         def serialize(writer: EoWriter, data: "ItemReplyServerPacket.ItemTypeDataExpReward") -> None:
             """
@@ -698,19 +610,19 @@ class ItemReplyServerPacket(Packet):
             Returns:
                 ItemReplyServerPacket.ItemTypeDataExpReward: The data to serialize.
             """
-            data: ItemReplyServerPacket.ItemTypeDataExpReward = ItemReplyServerPacket.ItemTypeDataExpReward()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._experience = reader.get_int()
-                data._level_up = reader.get_char()
-                data._stat_points = reader.get_short()
-                data._skill_points = reader.get_short()
-                data._max_hp = reader.get_short()
-                data._max_tp = reader.get_short()
-                data._max_sp = reader.get_short()
-                data._byte_size = reader.position - reader_start_position
-                return data
+                experience = reader.get_int()
+                level_up = reader.get_char()
+                stat_points = reader.get_short()
+                skill_points = reader.get_short()
+                max_hp = reader.get_short()
+                max_tp = reader.get_short()
+                max_sp = reader.get_short()
+                result = ItemReplyServerPacket.ItemTypeDataExpReward(experience=experience, level_up=level_up, stat_points=stat_points, skill_points=skill_points, max_hp=max_hp, max_tp=max_tp, max_sp=max_sp)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -15,6 +15,11 @@ class ItemSpecServerPacket(Packet):
     """
     _byte_size: int = 0
 
+    def __init__(self):
+        """
+        Create a new instance of ItemSpecServerPacket.
+        """
+
     @property
     def byte_size(self) -> int:
         """
@@ -80,13 +85,13 @@ class ItemSpecServerPacket(Packet):
         Returns:
             ItemSpecServerPacket: The data to serialize.
         """
-        data: ItemSpecServerPacket = ItemSpecServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.get_short()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = ItemSpecServerPacket()
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -15,7 +15,16 @@ class JukeboxAgreeServerPacket(Packet):
     Reply to successfully requesting a song
     """
     _byte_size: int = 0
-    _gold_amount: int = None # type: ignore [assignment]
+    _gold_amount: int
+
+    def __init__(self, *, gold_amount: int):
+        """
+        Create a new instance of JukeboxAgreeServerPacket.
+
+        Args:
+            gold_amount (int): (Value range is 0-4097152080.)
+        """
+        self._gold_amount = gold_amount
 
     @property
     def byte_size(self) -> int:
@@ -29,20 +38,8 @@ class JukeboxAgreeServerPacket(Packet):
 
     @property
     def gold_amount(self) -> int:
-        """
-        Note:
-          - Value range is 0-4097152080.
-        """
         return self._gold_amount
 
-    @gold_amount.setter
-    def gold_amount(self, gold_amount: int) -> None:
-        """
-        Note:
-          - Value range is 0-4097152080.
-        """
-        self._gold_amount = gold_amount
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -100,13 +97,13 @@ class JukeboxAgreeServerPacket(Packet):
         Returns:
             JukeboxAgreeServerPacket: The data to serialize.
         """
-        data: JukeboxAgreeServerPacket = JukeboxAgreeServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._gold_amount = reader.get_int()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            gold_amount = reader.get_int()
+            result = JukeboxAgreeServerPacket(gold_amount=gold_amount)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode