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

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

@@ -13,12 +13,31 @@ class CharacterBaseStatsWelcome:
     Sent upon selecting a character and entering the game.
     """
     _byte_size: int = 0
-    _str: int = None # type: ignore [assignment]
-    _wis: int = None # type: ignore [assignment]
-    _intl: int = None # type: ignore [assignment]
-    _agi: int = None # type: ignore [assignment]
-    _con: int = None # type: ignore [assignment]
-    _cha: int = None # type: ignore [assignment]
+    _str: int
+    _wis: int
+    _intl: int
+    _agi: int
+    _con: int
+    _cha: int
+
+    def __init__(self, *, str: int, wis: int, intl: int, agi: int, con: int, cha: int):
+        """
+        Create a new instance of CharacterBaseStatsWelcome.
+
+        Args:
+            str (int): (Value range is 0-64008.)
+            wis (int): (Value range is 0-64008.)
+            intl (int): (Value range is 0-64008.)
+            agi (int): (Value range is 0-64008.)
+            con (int): (Value range is 0-64008.)
+            cha (int): (Value range is 0-64008.)
+        """
+        self._str = str
+        self._wis = wis
+        self._intl = intl
+        self._agi = agi
+        self._con = con
+        self._cha = cha
 
     @property
     def byte_size(self) -> int:
@@ -32,100 +51,28 @@ class CharacterBaseStatsWelcome:
 
     @property
     def str(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._str
 
-    @str.setter
-    def str(self, str: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._str = str
-
     @property
     def wis(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._wis
 
-    @wis.setter
-    def wis(self, wis: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._wis = wis
-
     @property
     def intl(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._intl
 
-    @intl.setter
-    def intl(self, intl: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._intl = intl
-
     @property
     def agi(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._agi
 
-    @agi.setter
-    def agi(self, agi: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._agi = agi
-
     @property
     def con(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._con
 
-    @con.setter
-    def con(self, con: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._con = con
-
     @property
     def cha(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._cha
 
-    @cha.setter
-    def cha(self, cha: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._cha = cha
-
     @staticmethod
     def serialize(writer: EoWriter, data: "CharacterBaseStatsWelcome") -> None:
         """
@@ -135,24 +82,28 @@ class CharacterBaseStatsWelcome:
             writer (EoWriter): The writer that the data will be serialized to.
             data (CharacterBaseStatsWelcome): The data to serialize.
         """
-        if data._str is None:
-            raise SerializationError("str must be provided.")
-        writer.add_short(data._str)
-        if data._wis is None:
-            raise SerializationError("wis must be provided.")
-        writer.add_short(data._wis)
-        if data._intl is None:
-            raise SerializationError("intl must be provided.")
-        writer.add_short(data._intl)
-        if data._agi is None:
-            raise SerializationError("agi must be provided.")
-        writer.add_short(data._agi)
-        if data._con is None:
-            raise SerializationError("con must be provided.")
-        writer.add_short(data._con)
-        if data._cha is None:
-            raise SerializationError("cha must be provided.")
-        writer.add_short(data._cha)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._str is None:
+                raise SerializationError("str must be provided.")
+            writer.add_short(data._str)
+            if data._wis is None:
+                raise SerializationError("wis must be provided.")
+            writer.add_short(data._wis)
+            if data._intl is None:
+                raise SerializationError("intl must be provided.")
+            writer.add_short(data._intl)
+            if data._agi is None:
+                raise SerializationError("agi must be provided.")
+            writer.add_short(data._agi)
+            if data._con is None:
+                raise SerializationError("con must be provided.")
+            writer.add_short(data._con)
+            if data._cha is None:
+                raise SerializationError("cha must be provided.")
+            writer.add_short(data._cha)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CharacterBaseStatsWelcome":
@@ -165,18 +116,18 @@ class CharacterBaseStatsWelcome:
         Returns:
             CharacterBaseStatsWelcome: The data to serialize.
         """
-        data: CharacterBaseStatsWelcome = CharacterBaseStatsWelcome()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._str = reader.get_short()
-            data._wis = reader.get_short()
-            data._intl = reader.get_short()
-            data._agi = reader.get_short()
-            data._con = reader.get_short()
-            data._cha = reader.get_short()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            str = reader.get_short()
+            wis = reader.get_short()
+            intl = reader.get_short()
+            agi = reader.get_short()
+            con = reader.get_short()
+            cha = reader.get_short()
+            result = CharacterBaseStatsWelcome(str=str, wis=wis, intl=intl, agi=agi, con=con, cha=cha)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -14,16 +14,43 @@ class CharacterDetails:
     Information displayed on the paperdoll and book
     """
     _byte_size: int = 0
-    _name: str = None # type: ignore [assignment]
-    _home: str = None # type: ignore [assignment]
-    _partner: str = None # type: ignore [assignment]
-    _title: str = None # type: ignore [assignment]
-    _guild: str = None # type: ignore [assignment]
-    _guild_rank: str = None # type: ignore [assignment]
-    _player_id: int = None # type: ignore [assignment]
-    _class_id: int = None # type: ignore [assignment]
-    _gender: Gender = None # type: ignore [assignment]
-    _admin: AdminLevel = None # type: ignore [assignment]
+    _name: str
+    _home: str
+    _partner: str
+    _title: str
+    _guild: str
+    _guild_rank: str
+    _player_id: int
+    _class_id: int
+    _gender: Gender
+    _admin: AdminLevel
+
+    def __init__(self, *, name: str, home: str, partner: str, title: str, guild: str, guild_rank: str, player_id: int, class_id: int, gender: Gender, admin: AdminLevel):
+        """
+        Create a new instance of CharacterDetails.
+
+        Args:
+            name (str): 
+            home (str): 
+            partner (str): 
+            title (str): 
+            guild (str): 
+            guild_rank (str): 
+            player_id (int): (Value range is 0-64008.)
+            class_id (int): (Value range is 0-252.)
+            gender (Gender): 
+            admin (AdminLevel): 
+        """
+        self._name = name
+        self._home = home
+        self._partner = partner
+        self._title = title
+        self._guild = guild
+        self._guild_rank = guild_rank
+        self._player_id = player_id
+        self._class_id = class_id
+        self._gender = gender
+        self._admin = admin
 
     @property
     def byte_size(self) -> int:
@@ -39,98 +66,42 @@ class CharacterDetails:
     def name(self) -> str:
         return self._name
 
-    @name.setter
-    def name(self, name: str) -> None:
-        self._name = name
-
     @property
     def home(self) -> str:
         return self._home
 
-    @home.setter
-    def home(self, home: str) -> None:
-        self._home = home
-
     @property
     def partner(self) -> str:
         return self._partner
 
-    @partner.setter
-    def partner(self, partner: str) -> None:
-        self._partner = partner
-
     @property
     def title(self) -> str:
         return self._title
 
-    @title.setter
-    def title(self, title: str) -> None:
-        self._title = title
-
     @property
     def guild(self) -> str:
         return self._guild
 
-    @guild.setter
-    def guild(self, guild: str) -> None:
-        self._guild = guild
-
     @property
     def guild_rank(self) -> str:
         return self._guild_rank
 
-    @guild_rank.setter
-    def guild_rank(self, guild_rank: str) -> None:
-        self._guild_rank = guild_rank
-
     @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 class_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._class_id
 
-    @class_id.setter
-    def class_id(self, class_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._class_id = class_id
-
     @property
     def gender(self) -> Gender:
         return self._gender
 
-    @gender.setter
-    def gender(self, gender: Gender) -> None:
-        self._gender = gender
-
     @property
     def admin(self) -> AdminLevel:
         return self._admin
 
-    @admin.setter
-    def admin(self, admin: AdminLevel) -> None:
-        self._admin = admin
-
     @staticmethod
     def serialize(writer: EoWriter, data: "CharacterDetails") -> None:
         """
@@ -140,42 +111,48 @@ class CharacterDetails:
             writer (EoWriter): The writer that the data will be serialized to.
             data (CharacterDetails): The data to serialize.
         """
-        if data._name is None:
-            raise SerializationError("name must be provided.")
-        writer.add_string(data._name)
-        writer.add_byte(0xFF)
-        if data._home is None:
-            raise SerializationError("home must be provided.")
-        writer.add_string(data._home)
-        writer.add_byte(0xFF)
-        if data._partner is None:
-            raise SerializationError("partner must be provided.")
-        writer.add_string(data._partner)
-        writer.add_byte(0xFF)
-        if data._title is None:
-            raise SerializationError("title must be provided.")
-        writer.add_string(data._title)
-        writer.add_byte(0xFF)
-        if data._guild is None:
-            raise SerializationError("guild must be provided.")
-        writer.add_string(data._guild)
-        writer.add_byte(0xFF)
-        if data._guild_rank is None:
-            raise SerializationError("guild_rank must be provided.")
-        writer.add_string(data._guild_rank)
-        writer.add_byte(0xFF)
-        if data._player_id is None:
-            raise SerializationError("player_id must be provided.")
-        writer.add_short(data._player_id)
-        if data._class_id is None:
-            raise SerializationError("class_id must be provided.")
-        writer.add_char(data._class_id)
-        if data._gender is None:
-            raise SerializationError("gender must be provided.")
-        writer.add_char(int(data._gender))
-        if data._admin is None:
-            raise SerializationError("admin must be provided.")
-        writer.add_char(int(data._admin))
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._name is None:
+                raise SerializationError("name must be provided.")
+            writer.add_string(data._name)
+            writer.add_byte(0xFF)
+            if data._home is None:
+                raise SerializationError("home must be provided.")
+            writer.add_string(data._home)
+            writer.add_byte(0xFF)
+            if data._partner is None:
+                raise SerializationError("partner must be provided.")
+            writer.add_string(data._partner)
+            writer.add_byte(0xFF)
+            if data._title is None:
+                raise SerializationError("title must be provided.")
+            writer.add_string(data._title)
+            writer.add_byte(0xFF)
+            if data._guild is None:
+                raise SerializationError("guild must be provided.")
+            writer.add_string(data._guild)
+            writer.add_byte(0xFF)
+            if data._guild_rank is None:
+                raise SerializationError("guild_rank must be provided.")
+            writer.add_string(data._guild_rank)
+            writer.add_byte(0xFF)
+            if data._player_id is None:
+                raise SerializationError("player_id must be provided.")
+            writer.add_short(data._player_id)
+            if data._class_id is None:
+                raise SerializationError("class_id must be provided.")
+            writer.add_char(data._class_id)
+            if data._gender is None:
+                raise SerializationError("gender must be provided.")
+            writer.add_char(int(data._gender))
+            if data._admin is None:
+                raise SerializationError("admin must be provided.")
+            writer.add_char(int(data._admin))
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CharacterDetails":
@@ -188,30 +165,30 @@ class CharacterDetails:
         Returns:
             CharacterDetails: The data to serialize.
         """
-        data: CharacterDetails = CharacterDetails()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
-            data._name = reader.get_string()
+            name = reader.get_string()
             reader.next_chunk()
-            data._home = reader.get_string()
+            home = reader.get_string()
             reader.next_chunk()
-            data._partner = reader.get_string()
+            partner = reader.get_string()
             reader.next_chunk()
-            data._title = reader.get_string()
+            title = reader.get_string()
             reader.next_chunk()
-            data._guild = reader.get_string()
+            guild = reader.get_string()
             reader.next_chunk()
-            data._guild_rank = reader.get_string()
+            guild_rank = reader.get_string()
             reader.next_chunk()
-            data._player_id = reader.get_short()
-            data._class_id = reader.get_char()
-            data._gender = Gender(reader.get_char())
-            data._admin = AdminLevel(reader.get_char())
+            player_id = reader.get_short()
+            class_id = reader.get_char()
+            gender = Gender(reader.get_char())
+            admin = AdminLevel(reader.get_char())
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = CharacterDetails(name=name, home=home, partner=partner, title=title, guild=guild, guild_rank=guild_rank, player_id=player_id, class_id=class_id, gender=gender, admin=admin)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode