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

eolib/protocol/_generated/net/spell.py

@@ -12,8 +12,19 @@ class Spell:
     A spell known by the player
     """
     _byte_size: int = 0
-    _id: int = None # type: ignore [assignment]
-    _level: int = None # type: ignore [assignment]
+    _id: int
+    _level: int
+
+    def __init__(self, *, id: int, level: int):
+        """
+        Create a new instance of Spell.
+
+        Args:
+            id (int): (Value range is 0-64008.)
+            level (int): (Value range is 0-64008.)
+        """
+        self._id = id
+        self._level = level
 
     @property
     def byte_size(self) -> int:
@@ -27,36 +38,12 @@ class Spell:
 
     @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 level(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._level
 
-    @level.setter
-    def level(self, level: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._level = level
-
     @staticmethod
     def serialize(writer: EoWriter, data: "Spell") -> None:
         """
@@ -66,12 +53,16 @@ class Spell:
             writer (EoWriter): The writer that the data will be serialized to.
             data (Spell): The data to serialize.
         """
-        if data._id is None:
-            raise SerializationError("id must be provided.")
-        writer.add_short(data._id)
-        if data._level is None:
-            raise SerializationError("level must be provided.")
-        writer.add_short(data._level)
+        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._level is None:
+                raise SerializationError("level must be provided.")
+            writer.add_short(data._level)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "Spell":
@@ -84,14 +75,14 @@ class Spell:
         Returns:
             Spell: The data to serialize.
         """
-        data: Spell = Spell()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._id = reader.get_short()
-            data._level = reader.get_short()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            id = reader.get_short()
+            level = reader.get_short()
+            result = Spell(id=id, level=level)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/net/three_item.py

@@ -13,8 +13,19 @@ class ThreeItem:
     Used for shops, lockers, and various item transfers.
     """
     _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 ThreeItem.
+
+        Args:
+            id (int): (Value range is 0-64008.)
+            amount (int): (Value range is 0-16194276.)
+        """
+        self._id = id
+        self._amount = amount
 
     @property
     def byte_size(self) -> int:
@@ -28,36 +39,12 @@ class ThreeItem:
 
     @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-16194276.
-        """
         return self._amount
 
-    @amount.setter
-    def amount(self, amount: int) -> None:
-        """
-        Note:
-          - Value range is 0-16194276.
-        """
-        self._amount = amount
-
     @staticmethod
     def serialize(writer: EoWriter, data: "ThreeItem") -> None:
         """
@@ -67,12 +54,16 @@ class ThreeItem:
             writer (EoWriter): The writer that the data will be serialized to.
             data (ThreeItem): 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_three(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_three(data._amount)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ThreeItem":
@@ -85,14 +76,14 @@ class ThreeItem:
         Returns:
             ThreeItem: The data to serialize.
         """
-        data: ThreeItem = ThreeItem()
         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_three()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            id = reader.get_short()
+            amount = reader.get_three()
+            result = ThreeItem(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/version.py

@@ -12,9 +12,22 @@ class Version:
     Client version
     """
     _byte_size: int = 0
-    _major: int = None # type: ignore [assignment]
-    _minor: int = None # type: ignore [assignment]
-    _patch: int = None # type: ignore [assignment]
+    _major: int
+    _minor: int
+    _patch: int
+
+    def __init__(self, *, major: int, minor: int, patch: int):
+        """
+        Create a new instance of Version.
+
+        Args:
+            major (int): (Value range is 0-252.)
+            minor (int): (Value range is 0-252.)
+            patch (int): (Value range is 0-252.)
+        """
+        self._major = major
+        self._minor = minor
+        self._patch = patch
 
     @property
     def byte_size(self) -> int:
@@ -28,52 +41,16 @@ class Version:
 
     @property
     def major(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._major
 
-    @major.setter
-    def major(self, major: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._major = major
-
     @property
     def minor(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._minor
 
-    @minor.setter
-    def minor(self, minor: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._minor = minor
-
     @property
     def patch(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._patch
 
-    @patch.setter
-    def patch(self, patch: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._patch = patch
-
     @staticmethod
     def serialize(writer: EoWriter, data: "Version") -> None:
         """
@@ -83,15 +60,19 @@ class Version:
             writer (EoWriter): The writer that the data will be serialized to.
             data (Version): The data to serialize.
         """
-        if data._major is None:
-            raise SerializationError("major must be provided.")
-        writer.add_char(data._major)
-        if data._minor is None:
-            raise SerializationError("minor must be provided.")
-        writer.add_char(data._minor)
-        if data._patch is None:
-            raise SerializationError("patch must be provided.")
-        writer.add_char(data._patch)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._major is None:
+                raise SerializationError("major must be provided.")
+            writer.add_char(data._major)
+            if data._minor is None:
+                raise SerializationError("minor must be provided.")
+            writer.add_char(data._minor)
+            if data._patch is None:
+                raise SerializationError("patch must be provided.")
+            writer.add_char(data._patch)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "Version":
@@ -104,15 +85,15 @@ class Version:
         Returns:
             Version: The data to serialize.
         """
-        data: Version = Version()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._major = reader.get_char()
-            data._minor = reader.get_char()
-            data._patch = reader.get_char()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            major = reader.get_char()
+            minor = reader.get_char()
+            patch = reader.get_char()
+            result = Version(major=major, minor=minor, patch=patch)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/net/weight.py

@@ -12,8 +12,19 @@ class Weight:
     Current carry weight and maximum carry capacity of a player
     """
     _byte_size: int = 0
-    _current: int = None # type: ignore [assignment]
-    _max: int = None # type: ignore [assignment]
+    _current: int
+    _max: int
+
+    def __init__(self, *, current: int, max: int):
+        """
+        Create a new instance of Weight.
+
+        Args:
+            current (int): (Value range is 0-252.)
+            max (int): (Value range is 0-252.)
+        """
+        self._current = current
+        self._max = max
 
     @property
     def byte_size(self) -> int:
@@ -27,36 +38,12 @@ class Weight:
 
     @property
     def current(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._current
 
-    @current.setter
-    def current(self, current: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._current = current
-
     @property
     def max(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._max
 
-    @max.setter
-    def max(self, max: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._max = max
-
     @staticmethod
     def serialize(writer: EoWriter, data: "Weight") -> None:
         """
@@ -66,12 +53,16 @@ class Weight:
             writer (EoWriter): The writer that the data will be serialized to.
             data (Weight): The data to serialize.
         """
-        if data._current is None:
-            raise SerializationError("current must be provided.")
-        writer.add_char(data._current)
-        if data._max is None:
-            raise SerializationError("max must be provided.")
-        writer.add_char(data._max)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._current is None:
+                raise SerializationError("current must be provided.")
+            writer.add_char(data._current)
+            if data._max is None:
+                raise SerializationError("max must be provided.")
+            writer.add_char(data._max)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "Weight":
@@ -84,14 +75,14 @@ class Weight:
         Returns:
             Weight: The data to serialize.
         """
-        data: Weight = Weight()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._current = reader.get_char()
-            data._max = reader.get_char()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            current = reader.get_char()
+            max = reader.get_char()
+            result = Weight(current=current, max=max)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/pub/ecf.py

@@ -4,6 +4,7 @@
 # Changes will be lost when code is regenerated.
 
 from __future__ import annotations
+from collections.abc import Iterable
 from .ecf_record import EcfRecord
 from ...serialization_error import SerializationError
 from ....data.eo_writer import EoWriter
@@ -14,10 +15,25 @@ class Ecf:
     Endless Class File
     """
     _byte_size: int = 0
-    _rid: list[int] = None # type: ignore [assignment]
-    _total_classes_count: int = None # type: ignore [assignment]
-    _version: int = None # type: ignore [assignment]
-    _classes: list[EcfRecord] = None # type: ignore [assignment]
+    _rid: tuple[int, ...]
+    _total_classes_count: int
+    _version: int
+    _classes: tuple[EcfRecord, ...]
+
+    def __init__(self, *, rid: Iterable[int], total_classes_count: int, version: int, classes: Iterable[EcfRecord]):
+        """
+        Create a new instance of Ecf.
+
+        Args:
+            rid (Iterable[int]): (Length must be `2`.) (Element value range is 0-64008.)
+            total_classes_count (int): (Value range is 0-64008.)
+            version (int): (Value range is 0-252.)
+            classes (Iterable[EcfRecord]): 
+        """
+        self._rid = tuple(rid)
+        self._total_classes_count = total_classes_count
+        self._version = version
+        self._classes = tuple(classes)
 
     @property
     def byte_size(self) -> int:
@@ -30,63 +46,21 @@ class Ecf:
         return self._byte_size
 
     @property
-    def rid(self) -> list[int]:
-        """
-        Note:
-          - Length must be `2`.
-          - Element value range is 0-64008.
-        """
+    def rid(self) -> tuple[int, ...]:
         return self._rid
 
-    @rid.setter
-    def rid(self, rid: list[int]) -> None:
-        """
-        Note:
-          - Length must be `2`.
-          - Element value range is 0-64008.
-        """
-        self._rid = rid
-
     @property
     def total_classes_count(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._total_classes_count
 
-    @total_classes_count.setter
-    def total_classes_count(self, total_classes_count: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._total_classes_count = total_classes_count
-
     @property
     def version(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._version
 
-    @version.setter
-    def version(self, version: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._version = version
-
     @property
-    def classes(self) -> list[EcfRecord]:
+    def classes(self) -> tuple[EcfRecord, ...]:
         return self._classes
 
-    @classes.setter
-    def classes(self, classes: list[EcfRecord]) -> None:
-        self._classes = classes
-
     @staticmethod
     def serialize(writer: EoWriter, data: "Ecf") -> None:
         """
@@ -96,23 +70,27 @@ class Ecf:
             writer (EoWriter): The writer that the data will be serialized to.
             data (Ecf): The data to serialize.
         """
-        writer.add_fixed_string("ECF", 3, False)
-        if data._rid is None:
-            raise SerializationError("rid must be provided.")
-        if len(data._rid) != 2:
-            raise SerializationError(f"Expected length of rid to be exactly 2, got {len(data._rid)}.")
-        for i in range(2):
-            writer.add_short(data._rid[i])
-        if data._total_classes_count is None:
-            raise SerializationError("total_classes_count must be provided.")
-        writer.add_short(data._total_classes_count)
-        if data._version is None:
-            raise SerializationError("version must be provided.")
-        writer.add_char(data._version)
-        if data._classes is None:
-            raise SerializationError("classes must be provided.")
-        for i in range(len(data._classes)):
-            EcfRecord.serialize(writer, data._classes[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.add_fixed_string("ECF", 3, False)
+            if data._rid is None:
+                raise SerializationError("rid must be provided.")
+            if len(data._rid) != 2:
+                raise SerializationError(f"Expected length of rid to be exactly 2, got {len(data._rid)}.")
+            for i in range(2):
+                writer.add_short(data._rid[i])
+            if data._total_classes_count is None:
+                raise SerializationError("total_classes_count must be provided.")
+            writer.add_short(data._total_classes_count)
+            if data._version is None:
+                raise SerializationError("version must be provided.")
+            writer.add_char(data._version)
+            if data._classes is None:
+                raise SerializationError("classes must be provided.")
+            for i in range(len(data._classes)):
+                EcfRecord.serialize(writer, data._classes[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "Ecf":
@@ -125,21 +103,21 @@ class Ecf:
         Returns:
             Ecf: The data to serialize.
         """
-        data: Ecf = Ecf()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.get_fixed_string(3, False)
-            data._rid = []
+            rid = []
             for i in range(2):
-                data._rid.append(reader.get_short())
-            data._total_classes_count = reader.get_short()
-            data._version = reader.get_char()
-            data._classes = []
+                rid.append(reader.get_short())
+            total_classes_count = reader.get_short()
+            version = reader.get_char()
+            classes = []
             while reader.remaining > 0:
-                data._classes.append(EcfRecord.deserialize(reader))
-            data._byte_size = reader.position - reader_start_position
-            return data
+                classes.append(EcfRecord.deserialize(reader))
+            result = Ecf(rid=rid, total_classes_count=total_classes_count, version=version, classes=classes)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode