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

eolib/protocol/_generated/pub/eif.py

@@ -96,23 +96,27 @@ class Eif:
             writer (EoWriter): The writer that the data will be serialized to.
             data (Eif): The data to serialize.
         """
-        writer.add_fixed_string("EIF", 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_items_count is None:
-            raise SerializationError("total_items_count must be provided.")
-        writer.add_short(data._total_items_count)
-        if data._version is None:
-            raise SerializationError("version must be provided.")
-        writer.add_char(data._version)
-        if data._items is None:
-            raise SerializationError("items must be provided.")
-        for i in range(len(data._items)):
-            EifRecord.serialize(writer, data._items[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.add_fixed_string("EIF", 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_items_count is None:
+                raise SerializationError("total_items_count must be provided.")
+            writer.add_short(data._total_items_count)
+            if data._version is None:
+                raise SerializationError("version must be provided.")
+            writer.add_char(data._version)
+            if data._items is None:
+                raise SerializationError("items must be provided.")
+            for i in range(len(data._items)):
+                EifRecord.serialize(writer, data._items[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "Eif":

eolib/protocol/_generated/pub/eif_record.py

@@ -697,132 +697,136 @@ class EifRecord:
             writer (EoWriter): The writer that the data will be serialized to.
             data (EifRecord): The data to serialize.
         """
-        if data._name_length is None:
-            raise SerializationError("name_length must be provided.")
-        writer.add_char(data._name_length)
-        if data._name is None:
-            raise SerializationError("name must be provided.")
-        if len(data._name) > 252:
-            raise SerializationError(f"Expected length of name to be 252 or less, got {len(data._name)}.")
-        writer.add_fixed_string(data._name, data._name_length, False)
-        if data._graphic_id is None:
-            raise SerializationError("graphic_id must be provided.")
-        writer.add_short(data._graphic_id)
-        if data._type is None:
-            raise SerializationError("type must be provided.")
-        writer.add_char(int(data._type))
-        if data._subtype is None:
-            raise SerializationError("subtype must be provided.")
-        writer.add_char(int(data._subtype))
-        if data._special is None:
-            raise SerializationError("special must be provided.")
-        writer.add_char(int(data._special))
-        if data._hp is None:
-            raise SerializationError("hp must be provided.")
-        writer.add_short(data._hp)
-        if data._tp is None:
-            raise SerializationError("tp must be provided.")
-        writer.add_short(data._tp)
-        if data._min_damage is None:
-            raise SerializationError("min_damage must be provided.")
-        writer.add_short(data._min_damage)
-        if data._max_damage is None:
-            raise SerializationError("max_damage must be provided.")
-        writer.add_short(data._max_damage)
-        if data._accuracy is None:
-            raise SerializationError("accuracy must be provided.")
-        writer.add_short(data._accuracy)
-        if data._evade is None:
-            raise SerializationError("evade must be provided.")
-        writer.add_short(data._evade)
-        if data._armor is None:
-            raise SerializationError("armor must be provided.")
-        writer.add_short(data._armor)
-        if data._return_damage is None:
-            raise SerializationError("return_damage must be provided.")
-        writer.add_char(data._return_damage)
-        if data._str is None:
-            raise SerializationError("str must be provided.")
-        writer.add_char(data._str)
-        if data._intl is None:
-            raise SerializationError("intl must be provided.")
-        writer.add_char(data._intl)
-        if data._wis is None:
-            raise SerializationError("wis must be provided.")
-        writer.add_char(data._wis)
-        if data._agi is None:
-            raise SerializationError("agi must be provided.")
-        writer.add_char(data._agi)
-        if data._con is None:
-            raise SerializationError("con must be provided.")
-        writer.add_char(data._con)
-        if data._cha is None:
-            raise SerializationError("cha must be provided.")
-        writer.add_char(data._cha)
-        if data._light_resistance is None:
-            raise SerializationError("light_resistance must be provided.")
-        writer.add_char(data._light_resistance)
-        if data._dark_resistance is None:
-            raise SerializationError("dark_resistance must be provided.")
-        writer.add_char(data._dark_resistance)
-        if data._earth_resistance is None:
-            raise SerializationError("earth_resistance must be provided.")
-        writer.add_char(data._earth_resistance)
-        if data._air_resistance is None:
-            raise SerializationError("air_resistance must be provided.")
-        writer.add_char(data._air_resistance)
-        if data._water_resistance is None:
-            raise SerializationError("water_resistance must be provided.")
-        writer.add_char(data._water_resistance)
-        if data._fire_resistance is None:
-            raise SerializationError("fire_resistance must be provided.")
-        writer.add_char(data._fire_resistance)
-        if data._spec1 is None:
-            raise SerializationError("spec1 must be provided.")
-        writer.add_three(data._spec1)
-        if data._spec2 is None:
-            raise SerializationError("spec2 must be provided.")
-        writer.add_char(data._spec2)
-        if data._spec3 is None:
-            raise SerializationError("spec3 must be provided.")
-        writer.add_char(data._spec3)
-        if data._level_requirement is None:
-            raise SerializationError("level_requirement must be provided.")
-        writer.add_short(data._level_requirement)
-        if data._class_requirement is None:
-            raise SerializationError("class_requirement must be provided.")
-        writer.add_short(data._class_requirement)
-        if data._str_requirement is None:
-            raise SerializationError("str_requirement must be provided.")
-        writer.add_short(data._str_requirement)
-        if data._int_requirement is None:
-            raise SerializationError("int_requirement must be provided.")
-        writer.add_short(data._int_requirement)
-        if data._wis_requirement is None:
-            raise SerializationError("wis_requirement must be provided.")
-        writer.add_short(data._wis_requirement)
-        if data._agi_requirement is None:
-            raise SerializationError("agi_requirement must be provided.")
-        writer.add_short(data._agi_requirement)
-        if data._con_requirement is None:
-            raise SerializationError("con_requirement must be provided.")
-        writer.add_short(data._con_requirement)
-        if data._cha_requirement is None:
-            raise SerializationError("cha_requirement must be provided.")
-        writer.add_short(data._cha_requirement)
-        if data._element is None:
-            raise SerializationError("element must be provided.")
-        writer.add_char(int(data._element))
-        if data._element_damage is None:
-            raise SerializationError("element_damage must be provided.")
-        writer.add_char(data._element_damage)
-        if data._weight is None:
-            raise SerializationError("weight must be provided.")
-        writer.add_char(data._weight)
-        writer.add_char(0)
-        if data._size is None:
-            raise SerializationError("size must be provided.")
-        writer.add_char(int(data._size))
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._name_length is None:
+                raise SerializationError("name_length must be provided.")
+            writer.add_char(data._name_length)
+            if data._name is None:
+                raise SerializationError("name must be provided.")
+            if len(data._name) > 252:
+                raise SerializationError(f"Expected length of name to be 252 or less, got {len(data._name)}.")
+            writer.add_fixed_string(data._name, data._name_length, False)
+            if data._graphic_id is None:
+                raise SerializationError("graphic_id must be provided.")
+            writer.add_short(data._graphic_id)
+            if data._type is None:
+                raise SerializationError("type must be provided.")
+            writer.add_char(int(data._type))
+            if data._subtype is None:
+                raise SerializationError("subtype must be provided.")
+            writer.add_char(int(data._subtype))
+            if data._special is None:
+                raise SerializationError("special must be provided.")
+            writer.add_char(int(data._special))
+            if data._hp is None:
+                raise SerializationError("hp must be provided.")
+            writer.add_short(data._hp)
+            if data._tp is None:
+                raise SerializationError("tp must be provided.")
+            writer.add_short(data._tp)
+            if data._min_damage is None:
+                raise SerializationError("min_damage must be provided.")
+            writer.add_short(data._min_damage)
+            if data._max_damage is None:
+                raise SerializationError("max_damage must be provided.")
+            writer.add_short(data._max_damage)
+            if data._accuracy is None:
+                raise SerializationError("accuracy must be provided.")
+            writer.add_short(data._accuracy)
+            if data._evade is None:
+                raise SerializationError("evade must be provided.")
+            writer.add_short(data._evade)
+            if data._armor is None:
+                raise SerializationError("armor must be provided.")
+            writer.add_short(data._armor)
+            if data._return_damage is None:
+                raise SerializationError("return_damage must be provided.")
+            writer.add_char(data._return_damage)
+            if data._str is None:
+                raise SerializationError("str must be provided.")
+            writer.add_char(data._str)
+            if data._intl is None:
+                raise SerializationError("intl must be provided.")
+            writer.add_char(data._intl)
+            if data._wis is None:
+                raise SerializationError("wis must be provided.")
+            writer.add_char(data._wis)
+            if data._agi is None:
+                raise SerializationError("agi must be provided.")
+            writer.add_char(data._agi)
+            if data._con is None:
+                raise SerializationError("con must be provided.")
+            writer.add_char(data._con)
+            if data._cha is None:
+                raise SerializationError("cha must be provided.")
+            writer.add_char(data._cha)
+            if data._light_resistance is None:
+                raise SerializationError("light_resistance must be provided.")
+            writer.add_char(data._light_resistance)
+            if data._dark_resistance is None:
+                raise SerializationError("dark_resistance must be provided.")
+            writer.add_char(data._dark_resistance)
+            if data._earth_resistance is None:
+                raise SerializationError("earth_resistance must be provided.")
+            writer.add_char(data._earth_resistance)
+            if data._air_resistance is None:
+                raise SerializationError("air_resistance must be provided.")
+            writer.add_char(data._air_resistance)
+            if data._water_resistance is None:
+                raise SerializationError("water_resistance must be provided.")
+            writer.add_char(data._water_resistance)
+            if data._fire_resistance is None:
+                raise SerializationError("fire_resistance must be provided.")
+            writer.add_char(data._fire_resistance)
+            if data._spec1 is None:
+                raise SerializationError("spec1 must be provided.")
+            writer.add_three(data._spec1)
+            if data._spec2 is None:
+                raise SerializationError("spec2 must be provided.")
+            writer.add_char(data._spec2)
+            if data._spec3 is None:
+                raise SerializationError("spec3 must be provided.")
+            writer.add_char(data._spec3)
+            if data._level_requirement is None:
+                raise SerializationError("level_requirement must be provided.")
+            writer.add_short(data._level_requirement)
+            if data._class_requirement is None:
+                raise SerializationError("class_requirement must be provided.")
+            writer.add_short(data._class_requirement)
+            if data._str_requirement is None:
+                raise SerializationError("str_requirement must be provided.")
+            writer.add_short(data._str_requirement)
+            if data._int_requirement is None:
+                raise SerializationError("int_requirement must be provided.")
+            writer.add_short(data._int_requirement)
+            if data._wis_requirement is None:
+                raise SerializationError("wis_requirement must be provided.")
+            writer.add_short(data._wis_requirement)
+            if data._agi_requirement is None:
+                raise SerializationError("agi_requirement must be provided.")
+            writer.add_short(data._agi_requirement)
+            if data._con_requirement is None:
+                raise SerializationError("con_requirement must be provided.")
+            writer.add_short(data._con_requirement)
+            if data._cha_requirement is None:
+                raise SerializationError("cha_requirement must be provided.")
+            writer.add_short(data._cha_requirement)
+            if data._element is None:
+                raise SerializationError("element must be provided.")
+            writer.add_char(int(data._element))
+            if data._element_damage is None:
+                raise SerializationError("element_damage must be provided.")
+            writer.add_char(data._element_damage)
+            if data._weight is None:
+                raise SerializationError("weight must be provided.")
+            writer.add_char(data._weight)
+            writer.add_char(0)
+            if data._size is None:
+                raise SerializationError("size must be provided.")
+            writer.add_char(int(data._size))
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "EifRecord":

eolib/protocol/_generated/pub/enf.py

@@ -96,23 +96,27 @@ class Enf:
             writer (EoWriter): The writer that the data will be serialized to.
             data (Enf): The data to serialize.
         """
-        writer.add_fixed_string("ENF", 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_npcs_count is None:
-            raise SerializationError("total_npcs_count must be provided.")
-        writer.add_short(data._total_npcs_count)
-        if data._version is None:
-            raise SerializationError("version must be provided.")
-        writer.add_char(data._version)
-        if data._npcs is None:
-            raise SerializationError("npcs must be provided.")
-        for i in range(len(data._npcs)):
-            EnfRecord.serialize(writer, data._npcs[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.add_fixed_string("ENF", 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_npcs_count is None:
+                raise SerializationError("total_npcs_count must be provided.")
+            writer.add_short(data._total_npcs_count)
+            if data._version is None:
+                raise SerializationError("version must be provided.")
+            writer.add_char(data._version)
+            if data._npcs is None:
+                raise SerializationError("npcs must be provided.")
+            for i in range(len(data._npcs)):
+                EnfRecord.serialize(writer, data._npcs[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "Enf":

eolib/protocol/_generated/pub/enf_record.py

@@ -353,74 +353,78 @@ class EnfRecord:
             writer (EoWriter): The writer that the data will be serialized to.
             data (EnfRecord): The data to serialize.
         """
-        if data._name_length is None:
-            raise SerializationError("name_length must be provided.")
-        writer.add_char(data._name_length)
-        if data._name is None:
-            raise SerializationError("name must be provided.")
-        if len(data._name) > 252:
-            raise SerializationError(f"Expected length of name to be 252 or less, got {len(data._name)}.")
-        writer.add_fixed_string(data._name, data._name_length, False)
-        if data._graphic_id is None:
-            raise SerializationError("graphic_id must be provided.")
-        writer.add_short(data._graphic_id)
-        if data._race is None:
-            raise SerializationError("race must be provided.")
-        writer.add_char(data._race)
-        if data._boss is None:
-            raise SerializationError("boss must be provided.")
-        writer.add_short(1 if data._boss else 0)
-        if data._child is None:
-            raise SerializationError("child must be provided.")
-        writer.add_short(1 if data._child else 0)
-        if data._type is None:
-            raise SerializationError("type must be provided.")
-        writer.add_short(int(data._type))
-        if data._behavior_id is None:
-            raise SerializationError("behavior_id must be provided.")
-        writer.add_short(data._behavior_id)
-        if data._hp is None:
-            raise SerializationError("hp must be provided.")
-        writer.add_three(data._hp)
-        if data._tp is None:
-            raise SerializationError("tp must be provided.")
-        writer.add_short(data._tp)
-        if data._min_damage is None:
-            raise SerializationError("min_damage must be provided.")
-        writer.add_short(data._min_damage)
-        if data._max_damage is None:
-            raise SerializationError("max_damage must be provided.")
-        writer.add_short(data._max_damage)
-        if data._accuracy is None:
-            raise SerializationError("accuracy must be provided.")
-        writer.add_short(data._accuracy)
-        if data._evade is None:
-            raise SerializationError("evade must be provided.")
-        writer.add_short(data._evade)
-        if data._armor is None:
-            raise SerializationError("armor must be provided.")
-        writer.add_short(data._armor)
-        if data._return_damage is None:
-            raise SerializationError("return_damage must be provided.")
-        writer.add_char(data._return_damage)
-        if data._element is None:
-            raise SerializationError("element must be provided.")
-        writer.add_short(int(data._element))
-        if data._element_damage is None:
-            raise SerializationError("element_damage must be provided.")
-        writer.add_short(data._element_damage)
-        if data._element_weakness is None:
-            raise SerializationError("element_weakness must be provided.")
-        writer.add_short(int(data._element_weakness))
-        if data._element_weakness_damage is None:
-            raise SerializationError("element_weakness_damage must be provided.")
-        writer.add_short(data._element_weakness_damage)
-        if data._level is None:
-            raise SerializationError("level must be provided.")
-        writer.add_char(data._level)
-        if data._experience is None:
-            raise SerializationError("experience must be provided.")
-        writer.add_three(data._experience)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._name_length is None:
+                raise SerializationError("name_length must be provided.")
+            writer.add_char(data._name_length)
+            if data._name is None:
+                raise SerializationError("name must be provided.")
+            if len(data._name) > 252:
+                raise SerializationError(f"Expected length of name to be 252 or less, got {len(data._name)}.")
+            writer.add_fixed_string(data._name, data._name_length, False)
+            if data._graphic_id is None:
+                raise SerializationError("graphic_id must be provided.")
+            writer.add_short(data._graphic_id)
+            if data._race is None:
+                raise SerializationError("race must be provided.")
+            writer.add_char(data._race)
+            if data._boss is None:
+                raise SerializationError("boss must be provided.")
+            writer.add_short(1 if data._boss else 0)
+            if data._child is None:
+                raise SerializationError("child must be provided.")
+            writer.add_short(1 if data._child else 0)
+            if data._type is None:
+                raise SerializationError("type must be provided.")
+            writer.add_short(int(data._type))
+            if data._behavior_id is None:
+                raise SerializationError("behavior_id must be provided.")
+            writer.add_short(data._behavior_id)
+            if data._hp is None:
+                raise SerializationError("hp must be provided.")
+            writer.add_three(data._hp)
+            if data._tp is None:
+                raise SerializationError("tp must be provided.")
+            writer.add_short(data._tp)
+            if data._min_damage is None:
+                raise SerializationError("min_damage must be provided.")
+            writer.add_short(data._min_damage)
+            if data._max_damage is None:
+                raise SerializationError("max_damage must be provided.")
+            writer.add_short(data._max_damage)
+            if data._accuracy is None:
+                raise SerializationError("accuracy must be provided.")
+            writer.add_short(data._accuracy)
+            if data._evade is None:
+                raise SerializationError("evade must be provided.")
+            writer.add_short(data._evade)
+            if data._armor is None:
+                raise SerializationError("armor must be provided.")
+            writer.add_short(data._armor)
+            if data._return_damage is None:
+                raise SerializationError("return_damage must be provided.")
+            writer.add_char(data._return_damage)
+            if data._element is None:
+                raise SerializationError("element must be provided.")
+            writer.add_short(int(data._element))
+            if data._element_damage is None:
+                raise SerializationError("element_damage must be provided.")
+            writer.add_short(data._element_damage)
+            if data._element_weakness is None:
+                raise SerializationError("element_weakness must be provided.")
+            writer.add_short(int(data._element_weakness))
+            if data._element_weakness_damage is None:
+                raise SerializationError("element_weakness_damage must be provided.")
+            writer.add_short(data._element_weakness_damage)
+            if data._level is None:
+                raise SerializationError("level must be provided.")
+            writer.add_char(data._level)
+            if data._experience is None:
+                raise SerializationError("experience must be provided.")
+            writer.add_three(data._experience)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "EnfRecord":

eolib/protocol/_generated/pub/esf.py

@@ -96,23 +96,27 @@ class Esf:
             writer (EoWriter): The writer that the data will be serialized to.
             data (Esf): The data to serialize.
         """
-        writer.add_fixed_string("ESF", 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_skills_count is None:
-            raise SerializationError("total_skills_count must be provided.")
-        writer.add_short(data._total_skills_count)
-        if data._version is None:
-            raise SerializationError("version must be provided.")
-        writer.add_char(data._version)
-        if data._skills is None:
-            raise SerializationError("skills must be provided.")
-        for i in range(len(data._skills)):
-            EsfRecord.serialize(writer, data._skills[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.add_fixed_string("ESF", 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_skills_count is None:
+                raise SerializationError("total_skills_count must be provided.")
+            writer.add_short(data._total_skills_count)
+            if data._version is None:
+                raise SerializationError("version must be provided.")
+            writer.add_char(data._version)
+            if data._skills is None:
+                raise SerializationError("skills must be provided.")
+            for i in range(len(data._skills)):
+                EsfRecord.serialize(writer, data._skills[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "Esf":