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

eolib/protocol/_generated/net/client/sit_request_client_packet.py

@@ -18,8 +18,19 @@ class SitRequestClientPacket(Packet):
     Sit/stand request
     """
     _byte_size: int = 0
-    _sit_action: SitAction = None # type: ignore [assignment]
-    _sit_action_data: 'SitRequestClientPacket.SitActionData' = None
+    _sit_action: SitAction
+    _sit_action_data: 'SitRequestClientPacket.SitActionData'
+
+    def __init__(self, *, sit_action: SitAction, sit_action_data: 'SitRequestClientPacket.SitActionData' = None):
+        """
+        Create a new instance of SitRequestClientPacket.
+
+        Args:
+            sit_action (SitAction): 
+            sit_action_data (SitRequestClientPacket.SitActionData): Data associated with the `sit_action` field.
+        """
+        self._sit_action = sit_action
+        self._sit_action_data = sit_action_data
 
     @property
     def byte_size(self) -> int:
@@ -35,21 +46,13 @@ class SitRequestClientPacket(Packet):
     def sit_action(self) -> SitAction:
         return self._sit_action
 
-    @sit_action.setter
-    def sit_action(self, sit_action: SitAction) -> None:
-        self._sit_action = sit_action
-
     @property
     def sit_action_data(self) -> 'SitRequestClientPacket.SitActionData':
         """
-        SitRequestClientPacket.SitActionData: Gets or sets the data associated with the `sit_action` field.
+        SitRequestClientPacket.SitActionData: Data associated with the `sit_action` field.
         """
         return self._sit_action_data
 
-    @sit_action_data.setter
-    def sit_action_data(self, sit_action_data: 'SitRequestClientPacket.SitActionData') -> None:
-        self._sit_action_data = sit_action_data
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -88,13 +91,17 @@ class SitRequestClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SitRequestClientPacket): The data to serialize.
         """
-        if data._sit_action is None:
-            raise SerializationError("sit_action must be provided.")
-        writer.add_char(int(data._sit_action))
-        if data._sit_action == SitAction.Sit:
-            if not isinstance(data._sit_action_data, SitRequestClientPacket.SitActionDataSit):
-                raise SerializationError("Expected sit_action_data to be type SitRequestClientPacket.SitActionDataSit for sit_action " + SitAction(data._sit_action).name + ".")
-            SitRequestClientPacket.SitActionDataSit.serialize(writer, data._sit_action_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._sit_action is None:
+                raise SerializationError("sit_action must be provided.")
+            writer.add_char(int(data._sit_action))
+            if data._sit_action == SitAction.Sit:
+                if not isinstance(data._sit_action_data, SitRequestClientPacket.SitActionDataSit):
+                    raise SerializationError("Expected sit_action_data to be type SitRequestClientPacket.SitActionDataSit for sit_action " + SitAction(data._sit_action).name + ".")
+                SitRequestClientPacket.SitActionDataSit.serialize(writer, data._sit_action_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SitRequestClientPacket":
@@ -107,15 +114,16 @@ class SitRequestClientPacket(Packet):
         Returns:
             SitRequestClientPacket: The data to serialize.
         """
-        data: SitRequestClientPacket = SitRequestClientPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._sit_action = SitAction(reader.get_char())
-            if data._sit_action == SitAction.Sit:
-                data._sit_action_data = SitRequestClientPacket.SitActionDataSit.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            sit_action = SitAction(reader.get_char())
+            sit_action_data: SitRequestClientPacket.SitActionData = None
+            if sit_action == SitAction.Sit:
+                sit_action_data = SitRequestClientPacket.SitActionDataSit.deserialize(reader)
+            result = SitRequestClientPacket(sit_action=sit_action, sit_action_data=sit_action_data)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -123,17 +131,25 @@ class SitRequestClientPacket(Packet):
         return f"SitRequestClientPacket(byte_size={repr(self._byte_size)}, sit_action={repr(self._sit_action)}, sit_action_data={repr(self._sit_action_data)})"
 
     SitActionData = Union['SitRequestClientPacket.SitActionDataSit', None]
-    SitActionData.__doc__ = \
-        """
-        Data associated with different values of the `sit_action` field.
-        """
+    """
+    Data associated with different values of the `sit_action` field.
+    """
 
     class SitActionDataSit:
         """
         Data associated with sit_action value SitAction.Sit
         """
         _byte_size: int = 0
-        _cursor_coords: Coords = None # type: ignore [assignment]
+        _cursor_coords: Coords
+
+        def __init__(self, *, cursor_coords: Coords):
+            """
+            Create a new instance of SitRequestClientPacket.SitActionDataSit.
+
+            Args:
+                cursor_coords (Coords): The coordinates of the map cursor
+            """
+            self._cursor_coords = cursor_coords
 
         @property
         def byte_size(self) -> int:
@@ -152,13 +168,6 @@ class SitRequestClientPacket(Packet):
             """
             return self._cursor_coords
 
-        @cursor_coords.setter
-        def cursor_coords(self, cursor_coords: Coords) -> None:
-            """
-            The coordinates of the map cursor
-            """
-            self._cursor_coords = cursor_coords
-
         @staticmethod
         def serialize(writer: EoWriter, data: "SitRequestClientPacket.SitActionDataSit") -> None:
             """
@@ -168,9 +177,13 @@ class SitRequestClientPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (SitRequestClientPacket.SitActionDataSit): The data to serialize.
             """
-            if data._cursor_coords is None:
-                raise SerializationError("cursor_coords must be provided.")
-            Coords.serialize(writer, data._cursor_coords)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._cursor_coords is None:
+                    raise SerializationError("cursor_coords must be provided.")
+                Coords.serialize(writer, data._cursor_coords)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "SitRequestClientPacket.SitActionDataSit":
@@ -183,13 +196,13 @@ class SitRequestClientPacket(Packet):
             Returns:
                 SitRequestClientPacket.SitActionDataSit: The data to serialize.
             """
-            data: SitRequestClientPacket.SitActionDataSit = SitRequestClientPacket.SitActionDataSit()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._cursor_coords = Coords.deserialize(reader)
-                data._byte_size = reader.position - reader_start_position
-                return data
+                cursor_coords = Coords.deserialize(reader)
+                result = SitRequestClientPacket.SitActionDataSit(cursor_coords=cursor_coords)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/net/client/spell_request_client_packet.py

@@ -15,8 +15,19 @@ class SpellRequestClientPacket(Packet):
     Begin spell chanting
     """
     _byte_size: int = 0
-    _spell_id: int = None # type: ignore [assignment]
-    _timestamp: int = None # type: ignore [assignment]
+    _spell_id: int
+    _timestamp: int
+
+    def __init__(self, *, spell_id: int, timestamp: int):
+        """
+        Create a new instance of SpellRequestClientPacket.
+
+        Args:
+            spell_id (int): (Value range is 0-64008.)
+            timestamp (int): (Value range is 0-16194276.)
+        """
+        self._spell_id = spell_id
+        self._timestamp = timestamp
 
     @property
     def byte_size(self) -> int:
@@ -30,36 +41,12 @@ class SpellRequestClientPacket(Packet):
 
     @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 timestamp(self) -> int:
-        """
-        Note:
-          - Value range is 0-16194276.
-        """
         return self._timestamp
 
-    @timestamp.setter
-    def timestamp(self, timestamp: int) -> None:
-        """
-        Note:
-          - Value range is 0-16194276.
-        """
-        self._timestamp = timestamp
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -98,12 +85,16 @@ class SpellRequestClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellRequestClientPacket): The data to serialize.
         """
-        if data._spell_id is None:
-            raise SerializationError("spell_id must be provided.")
-        writer.add_short(data._spell_id)
-        if data._timestamp is None:
-            raise SerializationError("timestamp must be provided.")
-        writer.add_three(data._timestamp)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._spell_id is None:
+                raise SerializationError("spell_id must be provided.")
+            writer.add_short(data._spell_id)
+            if data._timestamp is None:
+                raise SerializationError("timestamp must be provided.")
+            writer.add_three(data._timestamp)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SpellRequestClientPacket":
@@ -116,14 +107,14 @@ class SpellRequestClientPacket(Packet):
         Returns:
             SpellRequestClientPacket: The data to serialize.
         """
-        data: SpellRequestClientPacket = SpellRequestClientPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._spell_id = reader.get_short()
-            data._timestamp = reader.get_three()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            spell_id = reader.get_short()
+            timestamp = reader.get_three()
+            result = SpellRequestClientPacket(spell_id=spell_id, timestamp=timestamp)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/net/client/spell_target_group_client_packet.py

@@ -15,8 +15,19 @@ class SpellTargetGroupClientPacket(Packet):
     Group spell cast
     """
     _byte_size: int = 0
-    _spell_id: int = None # type: ignore [assignment]
-    _timestamp: int = None # type: ignore [assignment]
+    _spell_id: int
+    _timestamp: int
+
+    def __init__(self, *, spell_id: int, timestamp: int):
+        """
+        Create a new instance of SpellTargetGroupClientPacket.
+
+        Args:
+            spell_id (int): (Value range is 0-64008.)
+            timestamp (int): (Value range is 0-16194276.)
+        """
+        self._spell_id = spell_id
+        self._timestamp = timestamp
 
     @property
     def byte_size(self) -> int:
@@ -30,36 +41,12 @@ class SpellTargetGroupClientPacket(Packet):
 
     @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 timestamp(self) -> int:
-        """
-        Note:
-          - Value range is 0-16194276.
-        """
         return self._timestamp
 
-    @timestamp.setter
-    def timestamp(self, timestamp: int) -> None:
-        """
-        Note:
-          - Value range is 0-16194276.
-        """
-        self._timestamp = timestamp
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -98,12 +85,16 @@ class SpellTargetGroupClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellTargetGroupClientPacket): The data to serialize.
         """
-        if data._spell_id is None:
-            raise SerializationError("spell_id must be provided.")
-        writer.add_short(data._spell_id)
-        if data._timestamp is None:
-            raise SerializationError("timestamp must be provided.")
-        writer.add_three(data._timestamp)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._spell_id is None:
+                raise SerializationError("spell_id must be provided.")
+            writer.add_short(data._spell_id)
+            if data._timestamp is None:
+                raise SerializationError("timestamp must be provided.")
+            writer.add_three(data._timestamp)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SpellTargetGroupClientPacket":
@@ -116,14 +107,14 @@ class SpellTargetGroupClientPacket(Packet):
         Returns:
             SpellTargetGroupClientPacket: The data to serialize.
         """
-        data: SpellTargetGroupClientPacket = SpellTargetGroupClientPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._spell_id = reader.get_short()
-            data._timestamp = reader.get_three()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            spell_id = reader.get_short()
+            timestamp = reader.get_three()
+            result = SpellTargetGroupClientPacket(spell_id=spell_id, timestamp=timestamp)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/net/client/spell_target_other_client_packet.py

@@ -16,11 +16,28 @@ class SpellTargetOtherClientPacket(Packet):
     Targeted spell cast
     """
     _byte_size: int = 0
-    _target_type: SpellTargetType = None # type: ignore [assignment]
-    _previous_timestamp: int = None # type: ignore [assignment]
-    _spell_id: int = None # type: ignore [assignment]
-    _victim_id: int = None # type: ignore [assignment]
-    _timestamp: int = None # type: ignore [assignment]
+    _target_type: SpellTargetType
+    _previous_timestamp: int
+    _spell_id: int
+    _victim_id: int
+    _timestamp: int
+
+    def __init__(self, *, target_type: SpellTargetType, previous_timestamp: int, spell_id: int, victim_id: int, timestamp: int):
+        """
+        Create a new instance of SpellTargetOtherClientPacket.
+
+        Args:
+            target_type (SpellTargetType): 
+            previous_timestamp (int): (Value range is 0-16194276.)
+            spell_id (int): (Value range is 0-64008.)
+            victim_id (int): (Value range is 0-64008.)
+            timestamp (int): (Value range is 0-16194276.)
+        """
+        self._target_type = target_type
+        self._previous_timestamp = previous_timestamp
+        self._spell_id = spell_id
+        self._victim_id = victim_id
+        self._timestamp = timestamp
 
     @property
     def byte_size(self) -> int:
@@ -36,74 +53,22 @@ class SpellTargetOtherClientPacket(Packet):
     def target_type(self) -> SpellTargetType:
         return self._target_type
 
-    @target_type.setter
-    def target_type(self, target_type: SpellTargetType) -> None:
-        self._target_type = target_type
-
     @property
     def previous_timestamp(self) -> int:
-        """
-        Note:
-          - Value range is 0-16194276.
-        """
         return self._previous_timestamp
 
-    @previous_timestamp.setter
-    def previous_timestamp(self, previous_timestamp: int) -> None:
-        """
-        Note:
-          - Value range is 0-16194276.
-        """
-        self._previous_timestamp = previous_timestamp
-
     @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 victim_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._victim_id
 
-    @victim_id.setter
-    def victim_id(self, victim_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._victim_id = victim_id
-
     @property
     def timestamp(self) -> int:
-        """
-        Note:
-          - Value range is 0-16194276.
-        """
         return self._timestamp
 
-    @timestamp.setter
-    def timestamp(self, timestamp: int) -> None:
-        """
-        Note:
-          - Value range is 0-16194276.
-        """
-        self._timestamp = timestamp
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -142,21 +107,25 @@ class SpellTargetOtherClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellTargetOtherClientPacket): The data to serialize.
         """
-        if data._target_type is None:
-            raise SerializationError("target_type must be provided.")
-        writer.add_char(int(data._target_type))
-        if data._previous_timestamp is None:
-            raise SerializationError("previous_timestamp must be provided.")
-        writer.add_three(data._previous_timestamp)
-        if data._spell_id is None:
-            raise SerializationError("spell_id must be provided.")
-        writer.add_short(data._spell_id)
-        if data._victim_id is None:
-            raise SerializationError("victim_id must be provided.")
-        writer.add_short(data._victim_id)
-        if data._timestamp is None:
-            raise SerializationError("timestamp must be provided.")
-        writer.add_three(data._timestamp)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._target_type is None:
+                raise SerializationError("target_type must be provided.")
+            writer.add_char(int(data._target_type))
+            if data._previous_timestamp is None:
+                raise SerializationError("previous_timestamp must be provided.")
+            writer.add_three(data._previous_timestamp)
+            if data._spell_id is None:
+                raise SerializationError("spell_id must be provided.")
+            writer.add_short(data._spell_id)
+            if data._victim_id is None:
+                raise SerializationError("victim_id must be provided.")
+            writer.add_short(data._victim_id)
+            if data._timestamp is None:
+                raise SerializationError("timestamp must be provided.")
+            writer.add_three(data._timestamp)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SpellTargetOtherClientPacket":
@@ -169,17 +138,17 @@ class SpellTargetOtherClientPacket(Packet):
         Returns:
             SpellTargetOtherClientPacket: The data to serialize.
         """
-        data: SpellTargetOtherClientPacket = SpellTargetOtherClientPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._target_type = SpellTargetType(reader.get_char())
-            data._previous_timestamp = reader.get_three()
-            data._spell_id = reader.get_short()
-            data._victim_id = reader.get_short()
-            data._timestamp = reader.get_three()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            target_type = SpellTargetType(reader.get_char())
+            previous_timestamp = reader.get_three()
+            spell_id = reader.get_short()
+            victim_id = reader.get_short()
+            timestamp = reader.get_three()
+            result = SpellTargetOtherClientPacket(target_type=target_type, previous_timestamp=previous_timestamp, spell_id=spell_id, victim_id=victim_id, timestamp=timestamp)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/net/client/spell_target_self_client_packet.py

@@ -16,9 +16,22 @@ class SpellTargetSelfClientPacket(Packet):
     Self-targeted spell cast
     """
     _byte_size: int = 0
-    _direction: Direction = None # type: ignore [assignment]
-    _spell_id: int = None # type: ignore [assignment]
-    _timestamp: int = None # type: ignore [assignment]
+    _direction: Direction
+    _spell_id: int
+    _timestamp: int
+
+    def __init__(self, *, direction: Direction, spell_id: int, timestamp: int):
+        """
+        Create a new instance of SpellTargetSelfClientPacket.
+
+        Args:
+            direction (Direction): 
+            spell_id (int): (Value range is 0-64008.)
+            timestamp (int): (Value range is 0-16194276.)
+        """
+        self._direction = direction
+        self._spell_id = spell_id
+        self._timestamp = timestamp
 
     @property
     def byte_size(self) -> int:
@@ -34,42 +47,14 @@ class SpellTargetSelfClientPacket(Packet):
     def direction(self) -> Direction:
         return self._direction
 
-    @direction.setter
-    def direction(self, direction: Direction) -> None:
-        self._direction = direction
-
     @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 timestamp(self) -> int:
-        """
-        Note:
-          - Value range is 0-16194276.
-        """
         return self._timestamp
 
-    @timestamp.setter
-    def timestamp(self, timestamp: int) -> None:
-        """
-        Note:
-          - Value range is 0-16194276.
-        """
-        self._timestamp = timestamp
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -108,15 +93,19 @@ class SpellTargetSelfClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellTargetSelfClientPacket): The data to serialize.
         """
-        if data._direction is None:
-            raise SerializationError("direction must be provided.")
-        writer.add_char(int(data._direction))
-        if data._spell_id is None:
-            raise SerializationError("spell_id must be provided.")
-        writer.add_short(data._spell_id)
-        if data._timestamp is None:
-            raise SerializationError("timestamp must be provided.")
-        writer.add_three(data._timestamp)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._direction is None:
+                raise SerializationError("direction must be provided.")
+            writer.add_char(int(data._direction))
+            if data._spell_id is None:
+                raise SerializationError("spell_id must be provided.")
+            writer.add_short(data._spell_id)
+            if data._timestamp is None:
+                raise SerializationError("timestamp must be provided.")
+            writer.add_three(data._timestamp)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SpellTargetSelfClientPacket":
@@ -129,15 +118,15 @@ class SpellTargetSelfClientPacket(Packet):
         Returns:
             SpellTargetSelfClientPacket: The data to serialize.
         """
-        data: SpellTargetSelfClientPacket = SpellTargetSelfClientPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._direction = Direction(reader.get_char())
-            data._spell_id = reader.get_short()
-            data._timestamp = reader.get_three()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            direction = Direction(reader.get_char())
+            spell_id = reader.get_short()
+            timestamp = reader.get_three()
+            result = SpellTargetSelfClientPacket(direction=direction, spell_id=spell_id, timestamp=timestamp)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode