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

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

@@ -15,7 +15,16 @@ class GuildUseClientPacket(Packet):
     Accepted a join request
     """
     _byte_size: int = 0
-    _player_id: int = None # type: ignore [assignment]
+    _player_id: int
+
+    def __init__(self, *, player_id: int):
+        """
+        Create a new instance of GuildUseClientPacket.
+
+        Args:
+            player_id (int): (Value range is 0-64008.)
+        """
+        self._player_id = player_id
 
     @property
     def byte_size(self) -> int:
@@ -29,20 +38,8 @@ class GuildUseClientPacket(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
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -81,9 +78,13 @@ class GuildUseClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GuildUseClientPacket): The data to serialize.
         """
-        if data._player_id is None:
-            raise SerializationError("player_id must be provided.")
-        writer.add_short(data._player_id)
+        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)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GuildUseClientPacket":
@@ -96,13 +97,13 @@ class GuildUseClientPacket(Packet):
         Returns:
             GuildUseClientPacket: The data to serialize.
         """
-        data: GuildUseClientPacket = GuildUseClientPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._player_id = reader.get_short()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            player_id = reader.get_short()
+            result = GuildUseClientPacket(player_id=player_id)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -17,10 +17,24 @@ class InitInitClientPacket(Packet):
     This packet is unencrypted.
     """
     _byte_size: int = 0
-    _challenge: int = None # type: ignore [assignment]
-    _version: Version = None # type: ignore [assignment]
-    _hdid_length: int = None # type: ignore [assignment]
-    _hdid: str = None # type: ignore [assignment]
+    _challenge: int
+    _version: Version
+    _hdid_length: int
+    _hdid: str
+
+    def __init__(self, *, challenge: int, version: Version, hdid: str):
+        """
+        Create a new instance of InitInitClientPacket.
+
+        Args:
+            challenge (int): (Value range is 0-16194276.)
+            version (Version): 
+            hdid (str): (Length must be 252 or less.)
+        """
+        self._challenge = challenge
+        self._version = version
+        self._hdid = hdid
+        self._hdid_length = len(self._hdid)
 
     @property
     def byte_size(self) -> int:
@@ -34,45 +48,16 @@ class InitInitClientPacket(Packet):
 
     @property
     def challenge(self) -> int:
-        """
-        Note:
-          - Value range is 0-16194276.
-        """
         return self._challenge
 
-    @challenge.setter
-    def challenge(self, challenge: int) -> None:
-        """
-        Note:
-          - Value range is 0-16194276.
-        """
-        self._challenge = challenge
-
     @property
     def version(self) -> Version:
         return self._version
 
-    @version.setter
-    def version(self, version: Version) -> None:
-        self._version = version
-
     @property
     def hdid(self) -> str:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
         return self._hdid
 
-    @hdid.setter
-    def hdid(self, hdid: str) -> None:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
-        self._hdid = hdid
-        self._hdid_length = len(self._hdid)
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -111,21 +96,25 @@ class InitInitClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (InitInitClientPacket): The data to serialize.
         """
-        if data._challenge is None:
-            raise SerializationError("challenge must be provided.")
-        writer.add_three(data._challenge)
-        if data._version is None:
-            raise SerializationError("version must be provided.")
-        Version.serialize(writer, data._version)
-        writer.add_char(112)
-        if data._hdid_length is None:
-            raise SerializationError("hdid_length must be provided.")
-        writer.add_char(data._hdid_length)
-        if data._hdid is None:
-            raise SerializationError("hdid must be provided.")
-        if len(data._hdid) > 252:
-            raise SerializationError(f"Expected length of hdid to be 252 or less, got {len(data._hdid)}.")
-        writer.add_fixed_string(data._hdid, data._hdid_length, False)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._challenge is None:
+                raise SerializationError("challenge must be provided.")
+            writer.add_three(data._challenge)
+            if data._version is None:
+                raise SerializationError("version must be provided.")
+            Version.serialize(writer, data._version)
+            writer.add_char(112)
+            if data._hdid_length is None:
+                raise SerializationError("hdid_length must be provided.")
+            writer.add_char(data._hdid_length)
+            if data._hdid is None:
+                raise SerializationError("hdid must be provided.")
+            if len(data._hdid) > 252:
+                raise SerializationError(f"Expected length of hdid to be 252 or less, got {len(data._hdid)}.")
+            writer.add_fixed_string(data._hdid, data._hdid_length, False)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "InitInitClientPacket":
@@ -138,17 +127,17 @@ class InitInitClientPacket(Packet):
         Returns:
             InitInitClientPacket: The data to serialize.
         """
-        data: InitInitClientPacket = InitInitClientPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._challenge = reader.get_three()
-            data._version = Version.deserialize(reader)
+            challenge = reader.get_three()
+            version = Version.deserialize(reader)
             reader.get_char()
-            data._hdid_length = reader.get_char()
-            data._hdid = reader.get_fixed_string(data._hdid_length, False)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            hdid_length = reader.get_char()
+            hdid = reader.get_fixed_string(hdid_length, False)
+            result = InitInitClientPacket(challenge=challenge, version=version, hdid=hdid)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -17,8 +17,19 @@ class ItemDropClientPacket(Packet):
     Dropping items on the ground
     """
     _byte_size: int = 0
-    _item: ThreeItem = None # type: ignore [assignment]
-    _coords: ByteCoords = None # type: ignore [assignment]
+    _item: ThreeItem
+    _coords: ByteCoords
+
+    def __init__(self, *, item: ThreeItem, coords: ByteCoords):
+        """
+        Create a new instance of ItemDropClientPacket.
+
+        Args:
+            item (ThreeItem): 
+            coords (ByteCoords): The official client sends 255 byte values for the coords if an item is dropped via the GUI button. 255 values here should be interpreted to mean "drop at current coords". Otherwise, the x and y fields contain encoded numbers that must be explicitly decoded to get the actual x and y values.
+        """
+        self._item = item
+        self._coords = coords
 
     @property
     def byte_size(self) -> int:
@@ -34,32 +45,17 @@ class ItemDropClientPacket(Packet):
     def item(self) -> ThreeItem:
         return self._item
 
-    @item.setter
-    def item(self, item: ThreeItem) -> None:
-        self._item = item
-
     @property
     def coords(self) -> ByteCoords:
         """
         The official client sends 255 byte values for the coords if an item is dropped via
         the GUI button.
-        255 values here should be interpreted to mean "drop at current coords".
+        255 values here should be interpreted to mean "drop at current coords".
         Otherwise, the x and y fields contain encoded numbers that must be explicitly
         decoded to get the actual x and y values.
         """
         return self._coords
 
-    @coords.setter
-    def coords(self, coords: ByteCoords) -> None:
-        """
-        The official client sends 255 byte values for the coords if an item is dropped via
-        the GUI button.
-        255 values here should be interpreted to mean "drop at current coords".
-        Otherwise, the x and y fields contain encoded numbers that must be explicitly
-        decoded to get the actual x and y values.
-        """
-        self._coords = coords
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -98,12 +94,16 @@ class ItemDropClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ItemDropClientPacket): The data to serialize.
         """
-        if data._item is None:
-            raise SerializationError("item must be provided.")
-        ThreeItem.serialize(writer, data._item)
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        ByteCoords.serialize(writer, data._coords)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._item is None:
+                raise SerializationError("item must be provided.")
+            ThreeItem.serialize(writer, data._item)
+            if data._coords is None:
+                raise SerializationError("coords must be provided.")
+            ByteCoords.serialize(writer, data._coords)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ItemDropClientPacket":
@@ -116,14 +116,14 @@ class ItemDropClientPacket(Packet):
         Returns:
             ItemDropClientPacket: The data to serialize.
         """
-        data: ItemDropClientPacket = ItemDropClientPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._item = ThreeItem.deserialize(reader)
-            data._coords = ByteCoords.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            item = ThreeItem.deserialize(reader)
+            coords = ByteCoords.deserialize(reader)
+            result = ItemDropClientPacket(item=item, coords=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/item_get_client_packet.py

@@ -15,7 +15,16 @@ class ItemGetClientPacket(Packet):
     Taking items from the ground
     """
     _byte_size: int = 0
-    _item_index: int = None # type: ignore [assignment]
+    _item_index: int
+
+    def __init__(self, *, item_index: int):
+        """
+        Create a new instance of ItemGetClientPacket.
+
+        Args:
+            item_index (int): (Value range is 0-64008.)
+        """
+        self._item_index = item_index
 
     @property
     def byte_size(self) -> int:
@@ -29,20 +38,8 @@ class ItemGetClientPacket(Packet):
 
     @property
     def item_index(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._item_index
 
-    @item_index.setter
-    def item_index(self, item_index: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._item_index = item_index
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -81,9 +78,13 @@ class ItemGetClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ItemGetClientPacket): The data to serialize.
         """
-        if data._item_index is None:
-            raise SerializationError("item_index must be provided.")
-        writer.add_short(data._item_index)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._item_index is None:
+                raise SerializationError("item_index must be provided.")
+            writer.add_short(data._item_index)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ItemGetClientPacket":
@@ -96,13 +97,13 @@ class ItemGetClientPacket(Packet):
         Returns:
             ItemGetClientPacket: The data to serialize.
         """
-        data: ItemGetClientPacket = ItemGetClientPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._item_index = reader.get_short()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            item_index = reader.get_short()
+            result = ItemGetClientPacket(item_index=item_index)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -16,7 +16,16 @@ class ItemJunkClientPacket(Packet):
     Junking items
     """
     _byte_size: int = 0
-    _item: Item = None # type: ignore [assignment]
+    _item: Item
+
+    def __init__(self, *, item: Item):
+        """
+        Create a new instance of ItemJunkClientPacket.
+
+        Args:
+            item (Item): 
+        """
+        self._item = item
 
     @property
     def byte_size(self) -> int:
@@ -32,10 +41,6 @@ class ItemJunkClientPacket(Packet):
     def item(self) -> Item:
         return self._item
 
-    @item.setter
-    def item(self, item: Item) -> None:
-        self._item = item
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -74,9 +79,13 @@ class ItemJunkClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ItemJunkClientPacket): The data to serialize.
         """
-        if data._item is None:
-            raise SerializationError("item must be provided.")
-        Item.serialize(writer, data._item)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._item is None:
+                raise SerializationError("item must be provided.")
+            Item.serialize(writer, data._item)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ItemJunkClientPacket":
@@ -89,13 +98,13 @@ class ItemJunkClientPacket(Packet):
         Returns:
             ItemJunkClientPacket: The data to serialize.
         """
-        data: ItemJunkClientPacket = ItemJunkClientPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._item = Item.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            item = Item.deserialize(reader)
+            result = ItemJunkClientPacket(item=item)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -15,7 +15,16 @@ class ItemUseClientPacket(Packet):
     Using an item
     """
     _byte_size: int = 0
-    _item_id: int = None # type: ignore [assignment]
+    _item_id: int
+
+    def __init__(self, *, item_id: int):
+        """
+        Create a new instance of ItemUseClientPacket.
+
+        Args:
+            item_id (int): (Value range is 0-64008.)
+        """
+        self._item_id = item_id
 
     @property
     def byte_size(self) -> int:
@@ -29,20 +38,8 @@ class ItemUseClientPacket(Packet):
 
     @property
     def item_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._item_id
 
-    @item_id.setter
-    def item_id(self, item_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._item_id = item_id
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -81,9 +78,13 @@ class ItemUseClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ItemUseClientPacket): The data to serialize.
         """
-        if data._item_id is None:
-            raise SerializationError("item_id must be provided.")
-        writer.add_short(data._item_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._item_id is None:
+                raise SerializationError("item_id must be provided.")
+            writer.add_short(data._item_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ItemUseClientPacket":
@@ -96,13 +97,13 @@ class ItemUseClientPacket(Packet):
         Returns:
             ItemUseClientPacket: The data to serialize.
         """
-        data: ItemUseClientPacket = ItemUseClientPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._item_id = reader.get_short()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            item_id = reader.get_short()
+            result = ItemUseClientPacket(item_id=item_id)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -15,7 +15,16 @@ class JukeboxMsgClientPacket(Packet):
     Requesting a song on a jukebox
     """
     _byte_size: int = 0
-    _track_id: int = None # type: ignore [assignment]
+    _track_id: int
+
+    def __init__(self, *, track_id: int):
+        """
+        Create a new instance of JukeboxMsgClientPacket.
+
+        Args:
+            track_id (int): This value is 0-indexed (Value range is 0-64008.)
+        """
+        self._track_id = track_id
 
     @property
     def byte_size(self) -> int:
@@ -30,19 +39,10 @@ class JukeboxMsgClientPacket(Packet):
     @property
     def track_id(self) -> int:
         """
-        Note:
-          - Value range is 0-64008.
+        This value is 0-indexed
         """
         return self._track_id
 
-    @track_id.setter
-    def track_id(self, track_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._track_id = track_id
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -81,11 +81,15 @@ class JukeboxMsgClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (JukeboxMsgClientPacket): The data to serialize.
         """
-        writer.add_char(0)
-        writer.add_char(0)
-        if data._track_id is None:
-            raise SerializationError("track_id must be provided.")
-        writer.add_short(data._track_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.add_char(0)
+            writer.add_char(0)
+            if data._track_id is None:
+                raise SerializationError("track_id must be provided.")
+            writer.add_short(data._track_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "JukeboxMsgClientPacket":
@@ -98,17 +102,15 @@ class JukeboxMsgClientPacket(Packet):
         Returns:
             JukeboxMsgClientPacket: The data to serialize.
         """
-        data: JukeboxMsgClientPacket = JukeboxMsgClientPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            reader.chunked_reading_mode = True
             reader.get_char()
             reader.get_char()
-            data._track_id = reader.get_short()
-            reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            track_id = reader.get_short()
+            result = JukeboxMsgClientPacket(track_id=track_id)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -16,7 +16,16 @@ class JukeboxOpenClientPacket(Packet):
     Opening the jukebox listing
     """
     _byte_size: int = 0
-    _coords: Coords = None # type: ignore [assignment]
+    _coords: Coords
+
+    def __init__(self, *, coords: Coords):
+        """
+        Create a new instance of JukeboxOpenClientPacket.
+
+        Args:
+            coords (Coords): 
+        """
+        self._coords = coords
 
     @property
     def byte_size(self) -> int:
@@ -32,10 +41,6 @@ class JukeboxOpenClientPacket(Packet):
     def coords(self) -> Coords:
         return self._coords
 
-    @coords.setter
-    def coords(self, coords: Coords) -> None:
-        self._coords = coords
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -74,9 +79,13 @@ class JukeboxOpenClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (JukeboxOpenClientPacket): The data to serialize.
         """
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._coords is None:
+                raise SerializationError("coords must be provided.")
+            Coords.serialize(writer, data._coords)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "JukeboxOpenClientPacket":
@@ -89,13 +98,13 @@ class JukeboxOpenClientPacket(Packet):
         Returns:
             JukeboxOpenClientPacket: The data to serialize.
         """
-        data: JukeboxOpenClientPacket = JukeboxOpenClientPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._coords = Coords.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            coords = Coords.deserialize(reader)
+            result = JukeboxOpenClientPacket(coords=coords)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode