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

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

@@ -4,6 +4,7 @@
 # Changes will be lost when code is regenerated.
 
 from __future__ import annotations
+from collections.abc import Iterable
 from ....serialization_error import SerializationError
 from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
@@ -15,18 +16,49 @@ class EquipmentWelcome:
     Note that these values are item IDs.
     """
     _byte_size: int = 0
-    _boots: int = None # type: ignore [assignment]
-    _gloves: int = None # type: ignore [assignment]
-    _accessory: int = None # type: ignore [assignment]
-    _armor: int = None # type: ignore [assignment]
-    _belt: int = None # type: ignore [assignment]
-    _necklace: int = None # type: ignore [assignment]
-    _hat: int = None # type: ignore [assignment]
-    _shield: int = None # type: ignore [assignment]
-    _weapon: int = None # type: ignore [assignment]
-    _ring: list[int] = None # type: ignore [assignment]
-    _armlet: list[int] = None # type: ignore [assignment]
-    _bracer: list[int] = None # type: ignore [assignment]
+    _boots: int
+    _gloves: int
+    _accessory: int
+    _armor: int
+    _belt: int
+    _necklace: int
+    _hat: int
+    _shield: int
+    _weapon: int
+    _ring: tuple[int, ...]
+    _armlet: tuple[int, ...]
+    _bracer: tuple[int, ...]
+
+    def __init__(self, *, boots: int, gloves: int, accessory: int, armor: int, belt: int, necklace: int, hat: int, shield: int, weapon: int, ring: Iterable[int], armlet: Iterable[int], bracer: Iterable[int]):
+        """
+        Create a new instance of EquipmentWelcome.
+
+        Args:
+            boots (int): (Value range is 0-64008.)
+            gloves (int): (Value range is 0-64008.)
+            accessory (int): (Value range is 0-64008.)
+            armor (int): (Value range is 0-64008.)
+            belt (int): (Value range is 0-64008.)
+            necklace (int): (Value range is 0-64008.)
+            hat (int): (Value range is 0-64008.)
+            shield (int): (Value range is 0-64008.)
+            weapon (int): (Value range is 0-64008.)
+            ring (Iterable[int]): (Length must be `2`.) (Element value range is 0-64008.)
+            armlet (Iterable[int]): (Length must be `2`.) (Element value range is 0-64008.)
+            bracer (Iterable[int]): (Length must be `2`.) (Element value range is 0-64008.)
+        """
+        self._boots = boots
+        self._gloves = gloves
+        self._accessory = accessory
+        self._armor = armor
+        self._belt = belt
+        self._necklace = necklace
+        self._hat = hat
+        self._shield = shield
+        self._weapon = weapon
+        self._ring = tuple(ring)
+        self._armlet = tuple(armlet)
+        self._bracer = tuple(bracer)
 
     @property
     def byte_size(self) -> int:
@@ -40,202 +72,52 @@ class EquipmentWelcome:
 
     @property
     def boots(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._boots
 
-    @boots.setter
-    def boots(self, boots: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._boots = boots
-
     @property
     def gloves(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._gloves
 
-    @gloves.setter
-    def gloves(self, gloves: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._gloves = gloves
-
     @property
     def accessory(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._accessory
 
-    @accessory.setter
-    def accessory(self, accessory: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._accessory = accessory
-
     @property
     def armor(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._armor
 
-    @armor.setter
-    def armor(self, armor: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._armor = armor
-
     @property
     def belt(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._belt
 
-    @belt.setter
-    def belt(self, belt: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._belt = belt
-
     @property
     def necklace(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._necklace
 
-    @necklace.setter
-    def necklace(self, necklace: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._necklace = necklace
-
     @property
     def hat(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._hat
 
-    @hat.setter
-    def hat(self, hat: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._hat = hat
-
     @property
     def shield(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._shield
 
-    @shield.setter
-    def shield(self, shield: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._shield = shield
-
     @property
     def weapon(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._weapon
 
-    @weapon.setter
-    def weapon(self, weapon: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._weapon = weapon
-
     @property
-    def ring(self) -> list[int]:
-        """
-        Note:
-          - Length must be `2`.
-          - Element value range is 0-64008.
-        """
+    def ring(self) -> tuple[int, ...]:
         return self._ring
 
-    @ring.setter
-    def ring(self, ring: list[int]) -> None:
-        """
-        Note:
-          - Length must be `2`.
-          - Element value range is 0-64008.
-        """
-        self._ring = ring
-
     @property
-    def armlet(self) -> list[int]:
-        """
-        Note:
-          - Length must be `2`.
-          - Element value range is 0-64008.
-        """
+    def armlet(self) -> tuple[int, ...]:
         return self._armlet
 
-    @armlet.setter
-    def armlet(self, armlet: list[int]) -> None:
-        """
-        Note:
-          - Length must be `2`.
-          - Element value range is 0-64008.
-        """
-        self._armlet = armlet
-
     @property
-    def bracer(self) -> list[int]:
-        """
-        Note:
-          - Length must be `2`.
-          - Element value range is 0-64008.
-        """
+    def bracer(self) -> tuple[int, ...]:
         return self._bracer
 
-    @bracer.setter
-    def bracer(self, bracer: list[int]) -> None:
-        """
-        Note:
-          - Length must be `2`.
-          - Element value range is 0-64008.
-        """
-        self._bracer = bracer
-
     @staticmethod
     def serialize(writer: EoWriter, data: "EquipmentWelcome") -> None:
         """
@@ -245,51 +127,55 @@ class EquipmentWelcome:
             writer (EoWriter): The writer that the data will be serialized to.
             data (EquipmentWelcome): The data to serialize.
         """
-        if data._boots is None:
-            raise SerializationError("boots must be provided.")
-        writer.add_short(data._boots)
-        if data._gloves is None:
-            raise SerializationError("gloves must be provided.")
-        writer.add_short(data._gloves)
-        if data._accessory is None:
-            raise SerializationError("accessory must be provided.")
-        writer.add_short(data._accessory)
-        if data._armor is None:
-            raise SerializationError("armor must be provided.")
-        writer.add_short(data._armor)
-        if data._belt is None:
-            raise SerializationError("belt must be provided.")
-        writer.add_short(data._belt)
-        if data._necklace is None:
-            raise SerializationError("necklace must be provided.")
-        writer.add_short(data._necklace)
-        if data._hat is None:
-            raise SerializationError("hat must be provided.")
-        writer.add_short(data._hat)
-        if data._shield is None:
-            raise SerializationError("shield must be provided.")
-        writer.add_short(data._shield)
-        if data._weapon is None:
-            raise SerializationError("weapon must be provided.")
-        writer.add_short(data._weapon)
-        if data._ring is None:
-            raise SerializationError("ring must be provided.")
-        if len(data._ring) != 2:
-            raise SerializationError(f"Expected length of ring to be exactly 2, got {len(data._ring)}.")
-        for i in range(2):
-            writer.add_short(data._ring[i])
-        if data._armlet is None:
-            raise SerializationError("armlet must be provided.")
-        if len(data._armlet) != 2:
-            raise SerializationError(f"Expected length of armlet to be exactly 2, got {len(data._armlet)}.")
-        for i in range(2):
-            writer.add_short(data._armlet[i])
-        if data._bracer is None:
-            raise SerializationError("bracer must be provided.")
-        if len(data._bracer) != 2:
-            raise SerializationError(f"Expected length of bracer to be exactly 2, got {len(data._bracer)}.")
-        for i in range(2):
-            writer.add_short(data._bracer[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._boots is None:
+                raise SerializationError("boots must be provided.")
+            writer.add_short(data._boots)
+            if data._gloves is None:
+                raise SerializationError("gloves must be provided.")
+            writer.add_short(data._gloves)
+            if data._accessory is None:
+                raise SerializationError("accessory must be provided.")
+            writer.add_short(data._accessory)
+            if data._armor is None:
+                raise SerializationError("armor must be provided.")
+            writer.add_short(data._armor)
+            if data._belt is None:
+                raise SerializationError("belt must be provided.")
+            writer.add_short(data._belt)
+            if data._necklace is None:
+                raise SerializationError("necklace must be provided.")
+            writer.add_short(data._necklace)
+            if data._hat is None:
+                raise SerializationError("hat must be provided.")
+            writer.add_short(data._hat)
+            if data._shield is None:
+                raise SerializationError("shield must be provided.")
+            writer.add_short(data._shield)
+            if data._weapon is None:
+                raise SerializationError("weapon must be provided.")
+            writer.add_short(data._weapon)
+            if data._ring is None:
+                raise SerializationError("ring must be provided.")
+            if len(data._ring) != 2:
+                raise SerializationError(f"Expected length of ring to be exactly 2, got {len(data._ring)}.")
+            for i in range(2):
+                writer.add_short(data._ring[i])
+            if data._armlet is None:
+                raise SerializationError("armlet must be provided.")
+            if len(data._armlet) != 2:
+                raise SerializationError(f"Expected length of armlet to be exactly 2, got {len(data._armlet)}.")
+            for i in range(2):
+                writer.add_short(data._armlet[i])
+            if data._bracer is None:
+                raise SerializationError("bracer must be provided.")
+            if len(data._bracer) != 2:
+                raise SerializationError(f"Expected length of bracer to be exactly 2, got {len(data._bracer)}.")
+            for i in range(2):
+                writer.add_short(data._bracer[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "EquipmentWelcome":
@@ -302,30 +188,30 @@ class EquipmentWelcome:
         Returns:
             EquipmentWelcome: The data to serialize.
         """
-        data: EquipmentWelcome = EquipmentWelcome()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._boots = reader.get_short()
-            data._gloves = reader.get_short()
-            data._accessory = reader.get_short()
-            data._armor = reader.get_short()
-            data._belt = reader.get_short()
-            data._necklace = reader.get_short()
-            data._hat = reader.get_short()
-            data._shield = reader.get_short()
-            data._weapon = reader.get_short()
-            data._ring = []
+            boots = reader.get_short()
+            gloves = reader.get_short()
+            accessory = reader.get_short()
+            armor = reader.get_short()
+            belt = reader.get_short()
+            necklace = reader.get_short()
+            hat = reader.get_short()
+            shield = reader.get_short()
+            weapon = reader.get_short()
+            ring = []
             for i in range(2):
-                data._ring.append(reader.get_short())
-            data._armlet = []
+                ring.append(reader.get_short())
+            armlet = []
             for i in range(2):
-                data._armlet.append(reader.get_short())
-            data._bracer = []
+                armlet.append(reader.get_short())
+            bracer = []
             for i in range(2):
-                data._bracer.append(reader.get_short())
-            data._byte_size = reader.position - reader_start_position
-            return data
+                bracer.append(reader.get_short())
+            result = EquipmentWelcome(boots=boots, gloves=gloves, accessory=accessory, armor=armor, belt=belt, necklace=necklace, hat=hat, shield=shield, weapon=weapon, ring=ring, armlet=armlet, bracer=bracer)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

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

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

@@ -12,8 +12,19 @@ class GlobalBackfillMessage:
     A backfilled global chat message
     """
     _byte_size: int = 0
-    _player_name: str = None # type: ignore [assignment]
-    _message: str = None # type: ignore [assignment]
+    _player_name: str
+    _message: str
+
+    def __init__(self, *, player_name: str, message: str):
+        """
+        Create a new instance of GlobalBackfillMessage.
+
+        Args:
+            player_name (str): 
+            message (str): 
+        """
+        self._player_name = player_name
+        self._message = message
 
     @property
     def byte_size(self) -> int:
@@ -29,18 +40,10 @@ class GlobalBackfillMessage:
     def player_name(self) -> str:
         return self._player_name
 
-    @player_name.setter
-    def player_name(self, player_name: str) -> None:
-        self._player_name = player_name
-
     @property
     def message(self) -> str:
         return self._message
 
-    @message.setter
-    def message(self, message: str) -> None:
-        self._message = message
-
     @staticmethod
     def serialize(writer: EoWriter, data: "GlobalBackfillMessage") -> None:
         """
@@ -50,13 +53,19 @@ class GlobalBackfillMessage:
             writer (EoWriter): The writer that the data will be serialized to.
             data (GlobalBackfillMessage): The data to serialize.
         """
-        if data._player_name is None:
-            raise SerializationError("player_name must be provided.")
-        writer.add_string(data._player_name)
-        writer.add_byte(0xFF)
-        if data._message is None:
-            raise SerializationError("message must be provided.")
-        writer.add_string(data._message)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._player_name is None:
+                raise SerializationError("player_name must be provided.")
+            writer.add_string(data._player_name)
+            writer.add_byte(0xFF)
+            if data._message is None:
+                raise SerializationError("message must be provided.")
+            writer.add_string(data._message)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GlobalBackfillMessage":
@@ -69,17 +78,17 @@ class GlobalBackfillMessage:
         Returns:
             GlobalBackfillMessage: The data to serialize.
         """
-        data: GlobalBackfillMessage = GlobalBackfillMessage()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
-            data._player_name = reader.get_string()
+            player_name = reader.get_string()
             reader.next_chunk()
-            data._message = reader.get_string()
+            message = reader.get_string()
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = GlobalBackfillMessage(player_name=player_name, message=message)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode