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

eolib/protocol/_generated/map/map_warp.py

@@ -13,10 +13,25 @@ class MapWarp:
     Warp EMF entity
     """
     _byte_size: int = 0
-    _destination_map: int = None # type: ignore [assignment]
-    _destination_coords: Coords = None # type: ignore [assignment]
-    _level_required: int = None # type: ignore [assignment]
-    _door: int = None # type: ignore [assignment]
+    _destination_map: int
+    _destination_coords: Coords
+    _level_required: int
+    _door: int
+
+    def __init__(self, *, destination_map: int, destination_coords: Coords, level_required: int, door: int):
+        """
+        Create a new instance of MapWarp.
+
+        Args:
+            destination_map (int): (Value range is 0-64008.)
+            destination_coords (Coords): 
+            level_required (int): (Value range is 0-252.)
+            door (int): (Value range is 0-64008.)
+        """
+        self._destination_map = destination_map
+        self._destination_coords = destination_coords
+        self._level_required = level_required
+        self._door = door
 
     @property
     def byte_size(self) -> int:
@@ -30,60 +45,20 @@ class MapWarp:
 
     @property
     def destination_map(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._destination_map
 
-    @destination_map.setter
-    def destination_map(self, destination_map: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._destination_map = destination_map
-
     @property
     def destination_coords(self) -> Coords:
         return self._destination_coords
 
-    @destination_coords.setter
-    def destination_coords(self, destination_coords: Coords) -> None:
-        self._destination_coords = destination_coords
-
     @property
     def level_required(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._level_required
 
-    @level_required.setter
-    def level_required(self, level_required: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._level_required = level_required
-
     @property
     def door(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._door
 
-    @door.setter
-    def door(self, door: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._door = door
-
     @staticmethod
     def serialize(writer: EoWriter, data: "MapWarp") -> None:
         """
@@ -93,18 +68,22 @@ class MapWarp:
             writer (EoWriter): The writer that the data will be serialized to.
             data (MapWarp): The data to serialize.
         """
-        if data._destination_map is None:
-            raise SerializationError("destination_map must be provided.")
-        writer.add_short(data._destination_map)
-        if data._destination_coords is None:
-            raise SerializationError("destination_coords must be provided.")
-        Coords.serialize(writer, data._destination_coords)
-        if data._level_required is None:
-            raise SerializationError("level_required must be provided.")
-        writer.add_char(data._level_required)
-        if data._door is None:
-            raise SerializationError("door must be provided.")
-        writer.add_short(data._door)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._destination_map is None:
+                raise SerializationError("destination_map must be provided.")
+            writer.add_short(data._destination_map)
+            if data._destination_coords is None:
+                raise SerializationError("destination_coords must be provided.")
+            Coords.serialize(writer, data._destination_coords)
+            if data._level_required is None:
+                raise SerializationError("level_required must be provided.")
+            writer.add_char(data._level_required)
+            if data._door is None:
+                raise SerializationError("door must be provided.")
+            writer.add_short(data._door)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MapWarp":
@@ -117,16 +96,16 @@ class MapWarp:
         Returns:
             MapWarp: The data to serialize.
         """
-        data: MapWarp = MapWarp()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._destination_map = reader.get_short()
-            data._destination_coords = Coords.deserialize(reader)
-            data._level_required = reader.get_char()
-            data._door = reader.get_short()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            destination_map = reader.get_short()
+            destination_coords = Coords.deserialize(reader)
+            level_required = reader.get_char()
+            door = reader.get_short()
+            result = MapWarp(destination_map=destination_map, destination_coords=destination_coords, level_required=level_required, door=door)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/map/map_warp_row.py

@@ -4,6 +4,7 @@
 # Changes will be lost when code is regenerated.
 
 from __future__ import annotations
+from collections.abc import Iterable
 from .map_warp_row_tile import MapWarpRowTile
 from ...serialization_error import SerializationError
 from ....data.eo_writer import EoWriter
@@ -14,9 +15,21 @@ class MapWarpRow:
     A row of warp entities
     """
     _byte_size: int = 0
-    _y: int = None # type: ignore [assignment]
-    _tiles_count: int = None # type: ignore [assignment]
-    _tiles: list[MapWarpRowTile] = None # type: ignore [assignment]
+    _y: int
+    _tiles_count: int
+    _tiles: tuple[MapWarpRowTile, ...]
+
+    def __init__(self, *, y: int, tiles: Iterable[MapWarpRowTile]):
+        """
+        Create a new instance of MapWarpRow.
+
+        Args:
+            y (int): (Value range is 0-252.)
+            tiles (Iterable[MapWarpRowTile]): (Length must be 252 or less.)
+        """
+        self._y = y
+        self._tiles = tuple(tiles)
+        self._tiles_count = len(self._tiles)
 
     @property
     def byte_size(self) -> int:
@@ -30,37 +43,12 @@ class MapWarpRow:
 
     @property
     def y(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._y
 
-    @y.setter
-    def y(self, y: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._y = y
-
     @property
-    def tiles(self) -> list[MapWarpRowTile]:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
+    def tiles(self) -> tuple[MapWarpRowTile, ...]:
         return self._tiles
 
-    @tiles.setter
-    def tiles(self, tiles: list[MapWarpRowTile]) -> None:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
-        self._tiles = tiles
-        self._tiles_count = len(self._tiles)
-
     @staticmethod
     def serialize(writer: EoWriter, data: "MapWarpRow") -> None:
         """
@@ -70,18 +58,22 @@ class MapWarpRow:
             writer (EoWriter): The writer that the data will be serialized to.
             data (MapWarpRow): The data to serialize.
         """
-        if data._y is None:
-            raise SerializationError("y must be provided.")
-        writer.add_char(data._y)
-        if data._tiles_count is None:
-            raise SerializationError("tiles_count must be provided.")
-        writer.add_char(data._tiles_count)
-        if data._tiles is None:
-            raise SerializationError("tiles must be provided.")
-        if len(data._tiles) > 252:
-            raise SerializationError(f"Expected length of tiles to be 252 or less, got {len(data._tiles)}.")
-        for i in range(data._tiles_count):
-            MapWarpRowTile.serialize(writer, data._tiles[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._y is None:
+                raise SerializationError("y must be provided.")
+            writer.add_char(data._y)
+            if data._tiles_count is None:
+                raise SerializationError("tiles_count must be provided.")
+            writer.add_char(data._tiles_count)
+            if data._tiles is None:
+                raise SerializationError("tiles must be provided.")
+            if len(data._tiles) > 252:
+                raise SerializationError(f"Expected length of tiles to be 252 or less, got {len(data._tiles)}.")
+            for i in range(data._tiles_count):
+                MapWarpRowTile.serialize(writer, data._tiles[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MapWarpRow":
@@ -94,17 +86,17 @@ class MapWarpRow:
         Returns:
             MapWarpRow: The data to serialize.
         """
-        data: MapWarpRow = MapWarpRow()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._y = reader.get_char()
-            data._tiles_count = reader.get_char()
-            data._tiles = []
-            for i in range(data._tiles_count):
-                data._tiles.append(MapWarpRowTile.deserialize(reader))
-            data._byte_size = reader.position - reader_start_position
-            return data
+            y = reader.get_char()
+            tiles_count = reader.get_char()
+            tiles = []
+            for i in range(tiles_count):
+                tiles.append(MapWarpRowTile.deserialize(reader))
+            result = MapWarpRow(y=y, tiles=tiles)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/map/map_warp_row_tile.py

@@ -13,8 +13,19 @@ class MapWarpRowTile:
     A single tile in a row of warp entities
     """
     _byte_size: int = 0
-    _x: int = None # type: ignore [assignment]
-    _warp: MapWarp = None # type: ignore [assignment]
+    _x: int
+    _warp: MapWarp
+
+    def __init__(self, *, x: int, warp: MapWarp):
+        """
+        Create a new instance of MapWarpRowTile.
+
+        Args:
+            x (int): (Value range is 0-252.)
+            warp (MapWarp): 
+        """
+        self._x = x
+        self._warp = warp
 
     @property
     def byte_size(self) -> int:
@@ -28,28 +39,12 @@ class MapWarpRowTile:
 
     @property
     def x(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._x
 
-    @x.setter
-    def x(self, x: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._x = x
-
     @property
     def warp(self) -> MapWarp:
         return self._warp
 
-    @warp.setter
-    def warp(self, warp: MapWarp) -> None:
-        self._warp = warp
-
     @staticmethod
     def serialize(writer: EoWriter, data: "MapWarpRowTile") -> None:
         """
@@ -59,12 +54,16 @@ class MapWarpRowTile:
             writer (EoWriter): The writer that the data will be serialized to.
             data (MapWarpRowTile): The data to serialize.
         """
-        if data._x is None:
-            raise SerializationError("x must be provided.")
-        writer.add_char(data._x)
-        if data._warp is None:
-            raise SerializationError("warp must be provided.")
-        MapWarp.serialize(writer, data._warp)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._x is None:
+                raise SerializationError("x must be provided.")
+            writer.add_char(data._x)
+            if data._warp is None:
+                raise SerializationError("warp must be provided.")
+            MapWarp.serialize(writer, data._warp)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MapWarpRowTile":
@@ -77,14 +76,14 @@ class MapWarpRowTile:
         Returns:
             MapWarpRowTile: The data to serialize.
         """
-        data: MapWarpRowTile = MapWarpRowTile()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._x = reader.get_char()
-            data._warp = MapWarp.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            x = reader.get_char()
+            warp = MapWarp.deserialize(reader)
+            result = MapWarpRowTile(x=x, warp=warp)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/net/char_item.py

@@ -13,8 +13,19 @@ class CharItem:
     Used for craft ingredients.
     """
     _byte_size: int = 0
-    _id: int = None # type: ignore [assignment]
-    _amount: int = None # type: ignore [assignment]
+    _id: int
+    _amount: int
+
+    def __init__(self, *, id: int, amount: int):
+        """
+        Create a new instance of CharItem.
+
+        Args:
+            id (int): (Value range is 0-64008.)
+            amount (int): (Value range is 0-252.)
+        """
+        self._id = id
+        self._amount = amount
 
     @property
     def byte_size(self) -> int:
@@ -28,36 +39,12 @@ class CharItem:
 
     @property
     def id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._id
 
-    @id.setter
-    def id(self, id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._id = id
-
     @property
     def amount(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._amount
 
-    @amount.setter
-    def amount(self, amount: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._amount = amount
-
     @staticmethod
     def serialize(writer: EoWriter, data: "CharItem") -> None:
         """
@@ -67,12 +54,16 @@ class CharItem:
             writer (EoWriter): The writer that the data will be serialized to.
             data (CharItem): The data to serialize.
         """
-        if data._id is None:
-            raise SerializationError("id must be provided.")
-        writer.add_short(data._id)
-        if data._amount is None:
-            raise SerializationError("amount must be provided.")
-        writer.add_char(data._amount)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._id is None:
+                raise SerializationError("id must be provided.")
+            writer.add_short(data._id)
+            if data._amount is None:
+                raise SerializationError("amount must be provided.")
+            writer.add_char(data._amount)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CharItem":
@@ -85,14 +76,14 @@ class CharItem:
         Returns:
             CharItem: The data to serialize.
         """
-        data: CharItem = CharItem()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._id = reader.get_short()
-            data._amount = reader.get_char()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            id = reader.get_short()
+            amount = reader.get_char()
+            result = CharItem(id=id, amount=amount)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -15,9 +15,22 @@ class AccountAgreeClientPacket(Packet):
     Change password
     """
     _byte_size: int = 0
-    _username: str = None # type: ignore [assignment]
-    _old_password: str = None # type: ignore [assignment]
-    _new_password: str = None # type: ignore [assignment]
+    _username: str
+    _old_password: str
+    _new_password: str
+
+    def __init__(self, *, username: str, old_password: str, new_password: str):
+        """
+        Create a new instance of AccountAgreeClientPacket.
+
+        Args:
+            username (str): 
+            old_password (str): 
+            new_password (str): 
+        """
+        self._username = username
+        self._old_password = old_password
+        self._new_password = new_password
 
     @property
     def byte_size(self) -> int:
@@ -33,26 +46,14 @@ class AccountAgreeClientPacket(Packet):
     def username(self) -> str:
         return self._username
 
-    @username.setter
-    def username(self, username: str) -> None:
-        self._username = username
-
     @property
     def old_password(self) -> str:
         return self._old_password
 
-    @old_password.setter
-    def old_password(self, old_password: str) -> None:
-        self._old_password = old_password
-
     @property
     def new_password(self) -> str:
         return self._new_password
 
-    @new_password.setter
-    def new_password(self, new_password: str) -> None:
-        self._new_password = new_password
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -91,18 +92,24 @@ class AccountAgreeClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (AccountAgreeClientPacket): The data to serialize.
         """
-        if data._username is None:
-            raise SerializationError("username must be provided.")
-        writer.add_string(data._username)
-        writer.add_byte(0xFF)
-        if data._old_password is None:
-            raise SerializationError("old_password must be provided.")
-        writer.add_string(data._old_password)
-        writer.add_byte(0xFF)
-        if data._new_password is None:
-            raise SerializationError("new_password must be provided.")
-        writer.add_string(data._new_password)
-        writer.add_byte(0xFF)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._username is None:
+                raise SerializationError("username must be provided.")
+            writer.add_string(data._username)
+            writer.add_byte(0xFF)
+            if data._old_password is None:
+                raise SerializationError("old_password must be provided.")
+            writer.add_string(data._old_password)
+            writer.add_byte(0xFF)
+            if data._new_password is None:
+                raise SerializationError("new_password must be provided.")
+            writer.add_string(data._new_password)
+            writer.add_byte(0xFF)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "AccountAgreeClientPacket":
@@ -115,20 +122,20 @@ class AccountAgreeClientPacket(Packet):
         Returns:
             AccountAgreeClientPacket: The data to serialize.
         """
-        data: AccountAgreeClientPacket = AccountAgreeClientPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
-            data._username = reader.get_string()
+            username = reader.get_string()
             reader.next_chunk()
-            data._old_password = reader.get_string()
+            old_password = reader.get_string()
             reader.next_chunk()
-            data._new_password = reader.get_string()
+            new_password = reader.get_string()
             reader.next_chunk()
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = AccountAgreeClientPacket(username=username, old_password=old_password, new_password=new_password)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode