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

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

@@ -97,17 +97,23 @@ class WelcomeReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (WelcomeReplyServerPacket): The data to serialize.
         """
-        if data._welcome_code is None:
-            raise SerializationError("welcome_code must be provided.")
-        writer.add_short(int(data._welcome_code))
-        if data._welcome_code == WelcomeCode.SelectCharacter:
-            if not isinstance(data._welcome_code_data, WelcomeReplyServerPacket.WelcomeCodeDataSelectCharacter):
-                raise SerializationError("Expected welcome_code_data to be type WelcomeReplyServerPacket.WelcomeCodeDataSelectCharacter for welcome_code " + WelcomeCode(data._welcome_code).name + ".")
-            WelcomeReplyServerPacket.WelcomeCodeDataSelectCharacter.serialize(writer, data._welcome_code_data)
-        elif data._welcome_code == WelcomeCode.EnterGame:
-            if not isinstance(data._welcome_code_data, WelcomeReplyServerPacket.WelcomeCodeDataEnterGame):
-                raise SerializationError("Expected welcome_code_data to be type WelcomeReplyServerPacket.WelcomeCodeDataEnterGame for welcome_code " + WelcomeCode(data._welcome_code).name + ".")
-            WelcomeReplyServerPacket.WelcomeCodeDataEnterGame.serialize(writer, data._welcome_code_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._welcome_code is None:
+                raise SerializationError("welcome_code must be provided.")
+            writer.add_short(int(data._welcome_code))
+            writer.string_sanitization_mode = True
+            if data._welcome_code == WelcomeCode.SelectCharacter:
+                if not isinstance(data._welcome_code_data, WelcomeReplyServerPacket.WelcomeCodeDataSelectCharacter):
+                    raise SerializationError("Expected welcome_code_data to be type WelcomeReplyServerPacket.WelcomeCodeDataSelectCharacter for welcome_code " + WelcomeCode(data._welcome_code).name + ".")
+                WelcomeReplyServerPacket.WelcomeCodeDataSelectCharacter.serialize(writer, data._welcome_code_data)
+            elif data._welcome_code == WelcomeCode.EnterGame:
+                if not isinstance(data._welcome_code_data, WelcomeReplyServerPacket.WelcomeCodeDataEnterGame):
+                    raise SerializationError("Expected welcome_code_data to be type WelcomeReplyServerPacket.WelcomeCodeDataEnterGame for welcome_code " + WelcomeCode(data._welcome_code).name + ".")
+                WelcomeReplyServerPacket.WelcomeCodeDataEnterGame.serialize(writer, data._welcome_code_data)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "WelcomeReplyServerPacket":
@@ -140,10 +146,9 @@ class WelcomeReplyServerPacket(Packet):
         return f"WelcomeReplyServerPacket(byte_size={repr(self._byte_size)}, welcome_code={repr(self._welcome_code)}, welcome_code_data={repr(self._welcome_code_data)})"
 
     WelcomeCodeData = Union['WelcomeReplyServerPacket.WelcomeCodeDataSelectCharacter', 'WelcomeReplyServerPacket.WelcomeCodeDataEnterGame', None]
-    WelcomeCodeData.__doc__ = \
-        """
-        Data associated with different values of the `welcome_code` field.
-        """
+    """
+    Data associated with different values of the `welcome_code` field.
+    """
 
     class WelcomeCodeDataSelectCharacter:
         """
@@ -584,112 +589,116 @@ class WelcomeReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (WelcomeReplyServerPacket.WelcomeCodeDataSelectCharacter): The data to serialize.
             """
-            if data._session_id is None:
-                raise SerializationError("session_id must be provided.")
-            writer.add_short(data._session_id)
-            if data._character_id is None:
-                raise SerializationError("character_id must be provided.")
-            writer.add_int(data._character_id)
-            if data._map_id is None:
-                raise SerializationError("map_id must be provided.")
-            writer.add_short(data._map_id)
-            if data._map_rid is None:
-                raise SerializationError("map_rid must be provided.")
-            if len(data._map_rid) != 2:
-                raise SerializationError(f"Expected length of map_rid to be exactly 2, got {len(data._map_rid)}.")
-            for i in range(2):
-                writer.add_short(data._map_rid[i])
-            if data._map_file_size is None:
-                raise SerializationError("map_file_size must be provided.")
-            writer.add_three(data._map_file_size)
-            if data._eif_rid is None:
-                raise SerializationError("eif_rid must be provided.")
-            if len(data._eif_rid) != 2:
-                raise SerializationError(f"Expected length of eif_rid to be exactly 2, got {len(data._eif_rid)}.")
-            for i in range(2):
-                writer.add_short(data._eif_rid[i])
-            if data._eif_length is None:
-                raise SerializationError("eif_length must be provided.")
-            writer.add_short(data._eif_length)
-            if data._enf_rid is None:
-                raise SerializationError("enf_rid must be provided.")
-            if len(data._enf_rid) != 2:
-                raise SerializationError(f"Expected length of enf_rid to be exactly 2, got {len(data._enf_rid)}.")
-            for i in range(2):
-                writer.add_short(data._enf_rid[i])
-            if data._enf_length is None:
-                raise SerializationError("enf_length must be provided.")
-            writer.add_short(data._enf_length)
-            if data._esf_rid is None:
-                raise SerializationError("esf_rid must be provided.")
-            if len(data._esf_rid) != 2:
-                raise SerializationError(f"Expected length of esf_rid to be exactly 2, got {len(data._esf_rid)}.")
-            for i in range(2):
-                writer.add_short(data._esf_rid[i])
-            if data._esf_length is None:
-                raise SerializationError("esf_length must be provided.")
-            writer.add_short(data._esf_length)
-            if data._ecf_rid is None:
-                raise SerializationError("ecf_rid must be provided.")
-            if len(data._ecf_rid) != 2:
-                raise SerializationError(f"Expected length of ecf_rid to be exactly 2, got {len(data._ecf_rid)}.")
-            for i in range(2):
-                writer.add_short(data._ecf_rid[i])
-            if data._ecf_length is None:
-                raise SerializationError("ecf_length must be provided.")
-            writer.add_short(data._ecf_length)
-            if data._name is None:
-                raise SerializationError("name must be provided.")
-            writer.add_string(data._name)
-            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_name is None:
-                raise SerializationError("guild_name must be provided.")
-            writer.add_string(data._guild_name)
-            writer.add_byte(0xFF)
-            if data._guild_rank_name is None:
-                raise SerializationError("guild_rank_name must be provided.")
-            writer.add_string(data._guild_rank_name)
-            writer.add_byte(0xFF)
-            if data._class_id is None:
-                raise SerializationError("class_id must be provided.")
-            writer.add_char(data._class_id)
-            if data._guild_tag is None:
-                raise SerializationError("guild_tag must be provided.")
-            if len(data._guild_tag) != 3:
-                raise SerializationError(f"Expected length of guild_tag to be exactly 3, got {len(data._guild_tag)}.")
-            writer.add_fixed_string(data._guild_tag, 3, False)
-            if data._admin is None:
-                raise SerializationError("admin must be provided.")
-            writer.add_char(int(data._admin))
-            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_int(data._experience)
-            if data._usage is None:
-                raise SerializationError("usage must be provided.")
-            writer.add_int(data._usage)
-            if data._stats is None:
-                raise SerializationError("stats must be provided.")
-            CharacterStatsWelcome.serialize(writer, data._stats)
-            if data._equipment is None:
-                raise SerializationError("equipment must be provided.")
-            EquipmentWelcome.serialize(writer, data._equipment)
-            if data._guild_rank is None:
-                raise SerializationError("guild_rank must be provided.")
-            writer.add_char(data._guild_rank)
-            if data._settings is None:
-                raise SerializationError("settings must be provided.")
-            ServerSettings.serialize(writer, data._settings)
-            if data._login_message_code is None:
-                raise SerializationError("login_message_code must be provided.")
-            writer.add_char(int(data._login_message_code))
-            writer.add_byte(0xFF)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._session_id is None:
+                    raise SerializationError("session_id must be provided.")
+                writer.add_short(data._session_id)
+                if data._character_id is None:
+                    raise SerializationError("character_id must be provided.")
+                writer.add_int(data._character_id)
+                if data._map_id is None:
+                    raise SerializationError("map_id must be provided.")
+                writer.add_short(data._map_id)
+                if data._map_rid is None:
+                    raise SerializationError("map_rid must be provided.")
+                if len(data._map_rid) != 2:
+                    raise SerializationError(f"Expected length of map_rid to be exactly 2, got {len(data._map_rid)}.")
+                for i in range(2):
+                    writer.add_short(data._map_rid[i])
+                if data._map_file_size is None:
+                    raise SerializationError("map_file_size must be provided.")
+                writer.add_three(data._map_file_size)
+                if data._eif_rid is None:
+                    raise SerializationError("eif_rid must be provided.")
+                if len(data._eif_rid) != 2:
+                    raise SerializationError(f"Expected length of eif_rid to be exactly 2, got {len(data._eif_rid)}.")
+                for i in range(2):
+                    writer.add_short(data._eif_rid[i])
+                if data._eif_length is None:
+                    raise SerializationError("eif_length must be provided.")
+                writer.add_short(data._eif_length)
+                if data._enf_rid is None:
+                    raise SerializationError("enf_rid must be provided.")
+                if len(data._enf_rid) != 2:
+                    raise SerializationError(f"Expected length of enf_rid to be exactly 2, got {len(data._enf_rid)}.")
+                for i in range(2):
+                    writer.add_short(data._enf_rid[i])
+                if data._enf_length is None:
+                    raise SerializationError("enf_length must be provided.")
+                writer.add_short(data._enf_length)
+                if data._esf_rid is None:
+                    raise SerializationError("esf_rid must be provided.")
+                if len(data._esf_rid) != 2:
+                    raise SerializationError(f"Expected length of esf_rid to be exactly 2, got {len(data._esf_rid)}.")
+                for i in range(2):
+                    writer.add_short(data._esf_rid[i])
+                if data._esf_length is None:
+                    raise SerializationError("esf_length must be provided.")
+                writer.add_short(data._esf_length)
+                if data._ecf_rid is None:
+                    raise SerializationError("ecf_rid must be provided.")
+                if len(data._ecf_rid) != 2:
+                    raise SerializationError(f"Expected length of ecf_rid to be exactly 2, got {len(data._ecf_rid)}.")
+                for i in range(2):
+                    writer.add_short(data._ecf_rid[i])
+                if data._ecf_length is None:
+                    raise SerializationError("ecf_length must be provided.")
+                writer.add_short(data._ecf_length)
+                if data._name is None:
+                    raise SerializationError("name must be provided.")
+                writer.add_string(data._name)
+                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_name is None:
+                    raise SerializationError("guild_name must be provided.")
+                writer.add_string(data._guild_name)
+                writer.add_byte(0xFF)
+                if data._guild_rank_name is None:
+                    raise SerializationError("guild_rank_name must be provided.")
+                writer.add_string(data._guild_rank_name)
+                writer.add_byte(0xFF)
+                if data._class_id is None:
+                    raise SerializationError("class_id must be provided.")
+                writer.add_char(data._class_id)
+                if data._guild_tag is None:
+                    raise SerializationError("guild_tag must be provided.")
+                if len(data._guild_tag) != 3:
+                    raise SerializationError(f"Expected length of guild_tag to be exactly 3, got {len(data._guild_tag)}.")
+                writer.add_fixed_string(data._guild_tag, 3, False)
+                if data._admin is None:
+                    raise SerializationError("admin must be provided.")
+                writer.add_char(int(data._admin))
+                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_int(data._experience)
+                if data._usage is None:
+                    raise SerializationError("usage must be provided.")
+                writer.add_int(data._usage)
+                if data._stats is None:
+                    raise SerializationError("stats must be provided.")
+                CharacterStatsWelcome.serialize(writer, data._stats)
+                if data._equipment is None:
+                    raise SerializationError("equipment must be provided.")
+                EquipmentWelcome.serialize(writer, data._equipment)
+                if data._guild_rank is None:
+                    raise SerializationError("guild_rank must be provided.")
+                writer.add_char(data._guild_rank)
+                if data._settings is None:
+                    raise SerializationError("settings must be provided.")
+                ServerSettings.serialize(writer, data._settings)
+                if data._login_message_code is None:
+                    raise SerializationError("login_message_code must be provided.")
+                writer.add_char(int(data._login_message_code))
+                writer.add_byte(0xFF)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "WelcomeReplyServerPacket.WelcomeCodeDataSelectCharacter":
@@ -835,31 +844,34 @@ class WelcomeReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (WelcomeReplyServerPacket.WelcomeCodeDataEnterGame): The data to serialize.
             """
-            writer.add_byte(0xFF)
-            if data._news is None:
-                raise SerializationError("news must be provided.")
-            if len(data._news) != 9:
-                raise SerializationError(f"Expected length of news to be exactly 9, got {len(data._news)}.")
-            for i in range(9):
-                if i > 0:
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                writer.add_byte(0xFF)
+                if data._news is None:
+                    raise SerializationError("news must be provided.")
+                if len(data._news) != 9:
+                    raise SerializationError(f"Expected length of news to be exactly 9, got {len(data._news)}.")
+                for i in range(9):
+                    writer.add_string(data._news[i])
                     writer.add_byte(0xFF)
-                writer.add_string(data._news[i])
-            if data._weight is None:
-                raise SerializationError("weight must be provided.")
-            Weight.serialize(writer, data._weight)
-            if data._items is None:
-                raise SerializationError("items must be provided.")
-            for i in range(len(data._items)):
-                Item.serialize(writer, data._items[i])
-            writer.add_byte(0xFF)
-            if data._spells is None:
-                raise SerializationError("spells must be provided.")
-            for i in range(len(data._spells)):
-                Spell.serialize(writer, data._spells[i])
-            writer.add_byte(0xFF)
-            if data._nearby is None:
-                raise SerializationError("nearby must be provided.")
-            NearbyInfo.serialize(writer, data._nearby)
+                if data._weight is None:
+                    raise SerializationError("weight must be provided.")
+                Weight.serialize(writer, data._weight)
+                if data._items is None:
+                    raise SerializationError("items must be provided.")
+                for i in range(len(data._items)):
+                    Item.serialize(writer, data._items[i])
+                writer.add_byte(0xFF)
+                if data._spells is None:
+                    raise SerializationError("spells must be provided.")
+                for i in range(len(data._spells)):
+                    Spell.serialize(writer, data._spells[i])
+                writer.add_byte(0xFF)
+                if data._nearby is None:
+                    raise SerializationError("nearby must be provided.")
+                NearbyInfo.serialize(writer, data._nearby)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "WelcomeReplyServerPacket.WelcomeCodeDataEnterGame":
@@ -880,8 +892,7 @@ class WelcomeReplyServerPacket(Packet):
                 data._news = []
                 for i in range(9):
                     data._news.append(reader.get_string())
-                    if i + 1 < 9:
-                        reader.next_chunk()
+                    reader.next_chunk()
                 data._weight = Weight.deserialize(reader)
                 items_length = int(reader.remaining / 6)
                 data._items = []

eolib/protocol/_generated/net/spell.py

@@ -66,12 +66,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":

eolib/protocol/_generated/net/three_item.py

@@ -67,12 +67,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":

eolib/protocol/_generated/net/version.py

@@ -83,15 +83,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":

eolib/protocol/_generated/net/weight.py

@@ -66,12 +66,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":

eolib/protocol/_generated/pub/ecf.py

@@ -96,23 +96,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":

eolib/protocol/_generated/pub/ecf_record.py

@@ -187,38 +187,42 @@ class EcfRecord:
             writer (EoWriter): The writer that the data will be serialized to.
             data (EcfRecord): 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._parent_type is None:
-            raise SerializationError("parent_type must be provided.")
-        writer.add_char(data._parent_type)
-        if data._stat_group is None:
-            raise SerializationError("stat_group must be provided.")
-        writer.add_char(data._stat_group)
-        if data._str is None:
-            raise SerializationError("str must be provided.")
-        writer.add_short(data._str)
-        if data._intl is None:
-            raise SerializationError("intl must be provided.")
-        writer.add_short(data._intl)
-        if data._wis is None:
-            raise SerializationError("wis must be provided.")
-        writer.add_short(data._wis)
-        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._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._parent_type is None:
+                raise SerializationError("parent_type must be provided.")
+            writer.add_char(data._parent_type)
+            if data._stat_group is None:
+                raise SerializationError("stat_group must be provided.")
+            writer.add_char(data._stat_group)
+            if data._str is None:
+                raise SerializationError("str must be provided.")
+            writer.add_short(data._str)
+            if data._intl is None:
+                raise SerializationError("intl must be provided.")
+            writer.add_short(data._intl)
+            if data._wis is None:
+                raise SerializationError("wis must be provided.")
+            writer.add_short(data._wis)
+            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) -> "EcfRecord":