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

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

@@ -121,24 +121,28 @@ class CharacterStatsUpdate:
             writer (EoWriter): The writer that the data will be serialized to.
             data (CharacterStatsUpdate): The data to serialize.
         """
-        if data._base_stats is None:
-            raise SerializationError("base_stats must be provided.")
-        CharacterBaseStats.serialize(writer, data._base_stats)
-        if data._max_hp is None:
-            raise SerializationError("max_hp must be provided.")
-        writer.add_short(data._max_hp)
-        if data._max_tp is None:
-            raise SerializationError("max_tp must be provided.")
-        writer.add_short(data._max_tp)
-        if data._max_sp is None:
-            raise SerializationError("max_sp must be provided.")
-        writer.add_short(data._max_sp)
-        if data._max_weight is None:
-            raise SerializationError("max_weight must be provided.")
-        writer.add_short(data._max_weight)
-        if data._secondary_stats is None:
-            raise SerializationError("secondary_stats must be provided.")
-        CharacterSecondaryStats.serialize(writer, data._secondary_stats)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._base_stats is None:
+                raise SerializationError("base_stats must be provided.")
+            CharacterBaseStats.serialize(writer, data._base_stats)
+            if data._max_hp is None:
+                raise SerializationError("max_hp must be provided.")
+            writer.add_short(data._max_hp)
+            if data._max_tp is None:
+                raise SerializationError("max_tp must be provided.")
+            writer.add_short(data._max_tp)
+            if data._max_sp is None:
+                raise SerializationError("max_sp must be provided.")
+            writer.add_short(data._max_sp)
+            if data._max_weight is None:
+                raise SerializationError("max_weight must be provided.")
+            writer.add_short(data._max_weight)
+            if data._secondary_stats is None:
+                raise SerializationError("secondary_stats must be provided.")
+            CharacterSecondaryStats.serialize(writer, data._secondary_stats)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CharacterStatsUpdate":

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

@@ -189,36 +189,40 @@ class CharacterStatsWelcome:
             writer (EoWriter): The writer that the data will be serialized to.
             data (CharacterStatsWelcome): The data to serialize.
         """
-        if data._hp is None:
-            raise SerializationError("hp must be provided.")
-        writer.add_short(data._hp)
-        if data._max_hp is None:
-            raise SerializationError("max_hp must be provided.")
-        writer.add_short(data._max_hp)
-        if data._tp is None:
-            raise SerializationError("tp must be provided.")
-        writer.add_short(data._tp)
-        if data._max_tp is None:
-            raise SerializationError("max_tp must be provided.")
-        writer.add_short(data._max_tp)
-        if data._max_sp is None:
-            raise SerializationError("max_sp must be provided.")
-        writer.add_short(data._max_sp)
-        if data._stat_points is None:
-            raise SerializationError("stat_points must be provided.")
-        writer.add_short(data._stat_points)
-        if data._skill_points is None:
-            raise SerializationError("skill_points must be provided.")
-        writer.add_short(data._skill_points)
-        if data._karma is None:
-            raise SerializationError("karma must be provided.")
-        writer.add_short(data._karma)
-        if data._secondary is None:
-            raise SerializationError("secondary must be provided.")
-        CharacterSecondaryStats.serialize(writer, data._secondary)
-        if data._base is None:
-            raise SerializationError("base must be provided.")
-        CharacterBaseStatsWelcome.serialize(writer, data._base)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._hp is None:
+                raise SerializationError("hp must be provided.")
+            writer.add_short(data._hp)
+            if data._max_hp is None:
+                raise SerializationError("max_hp must be provided.")
+            writer.add_short(data._max_hp)
+            if data._tp is None:
+                raise SerializationError("tp must be provided.")
+            writer.add_short(data._tp)
+            if data._max_tp is None:
+                raise SerializationError("max_tp must be provided.")
+            writer.add_short(data._max_tp)
+            if data._max_sp is None:
+                raise SerializationError("max_sp must be provided.")
+            writer.add_short(data._max_sp)
+            if data._stat_points is None:
+                raise SerializationError("stat_points must be provided.")
+            writer.add_short(data._stat_points)
+            if data._skill_points is None:
+                raise SerializationError("skill_points must be provided.")
+            writer.add_short(data._skill_points)
+            if data._karma is None:
+                raise SerializationError("karma must be provided.")
+            writer.add_short(data._karma)
+            if data._secondary is None:
+                raise SerializationError("secondary must be provided.")
+            CharacterSecondaryStats.serialize(writer, data._secondary)
+            if data._base is None:
+                raise SerializationError("base must be provided.")
+            CharacterBaseStatsWelcome.serialize(writer, data._base)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CharacterStatsWelcome":

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ChestAgreeServerPacket(Packet):
+    """
+    Chest contents updating
+    """
     _byte_size: int = 0
     _items: list[ThreeItem] = None # type: ignore [assignment]
 
@@ -72,10 +75,14 @@ class ChestAgreeServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ChestAgreeServerPacket): The data to serialize.
         """
-        if data._items is None:
-            raise SerializationError("items must be provided.")
-        for i in range(len(data._items)):
-            ThreeItem.serialize(writer, data._items[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._items is None:
+                raise SerializationError("items must be provided.")
+            for i in range(len(data._items)):
+                ThreeItem.serialize(writer, data._items[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ChestAgreeServerPacket":

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

@@ -12,6 +12,10 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ChestCloseServerPacket(Packet):
+    """
+    Reply to trying to interact with a locked or "broken" chest.
+    The official client assumes a broken chest if the packet is under 2 bytes in length.
+    """
     _byte_size: int = 0
     _key: Optional[int] = None # type: ignore [assignment]
 
@@ -83,10 +87,16 @@ class ChestCloseServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ChestCloseServerPacket): The data to serialize.
         """
-        reached_missing_optional = data._key is None
-        if not reached_missing_optional:
-            writer.add_short(cast(int, data._key))
-        writer.add_string("N")
+        old_writer_length: int = len(writer)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            reached_missing_optional = data._key is None
+            if not reached_missing_optional:
+                writer.add_short(cast(int, data._key))
+            if len(writer) == old_writer_length:
+                writer.add_string("N")
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ChestCloseServerPacket":
@@ -105,7 +115,8 @@ class ChestCloseServerPacket(Packet):
             reader_start_position: int = reader.position
             if reader.remaining > 0:
                 data._key = reader.get_short()
-            reader.get_string()
+            if reader.position == reader_start_position:
+                reader.get_string()
             data._byte_size = reader.position - reader_start_position
             return data
         finally:

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

@@ -14,6 +14,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ChestGetServerPacket(Packet):
+    """
+    Reply to removing an item from a chest
+    """
     _byte_size: int = 0
     _taken_item: ThreeItem = None # type: ignore [assignment]
     _weight: Weight = None # type: ignore [assignment]
@@ -91,16 +94,20 @@ class ChestGetServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ChestGetServerPacket): The data to serialize.
         """
-        if data._taken_item is None:
-            raise SerializationError("taken_item must be provided.")
-        ThreeItem.serialize(writer, data._taken_item)
-        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)):
-            ThreeItem.serialize(writer, data._items[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._taken_item is None:
+                raise SerializationError("taken_item must be provided.")
+            ThreeItem.serialize(writer, data._taken_item)
+            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)):
+                ThreeItem.serialize(writer, data._items[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ChestGetServerPacket":

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

@@ -14,6 +14,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ChestOpenServerPacket(Packet):
+    """
+    Reply to opening a chest
+    """
     _byte_size: int = 0
     _coords: Coords = None # type: ignore [assignment]
     _items: list[ThreeItem] = None # type: ignore [assignment]
@@ -82,13 +85,17 @@ class ChestOpenServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ChestOpenServerPacket): The data to serialize.
         """
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
-        if data._items is None:
-            raise SerializationError("items must be provided.")
-        for i in range(len(data._items)):
-            ThreeItem.serialize(writer, data._items[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._coords is None:
+                raise SerializationError("coords must be provided.")
+            Coords.serialize(writer, data._coords)
+            if data._items is None:
+                raise SerializationError("items must be provided.")
+            for i in range(len(data._items)):
+                ThreeItem.serialize(writer, data._items[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ChestOpenServerPacket":

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

@@ -14,6 +14,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ChestReplyServerPacket(Packet):
+    """
+    Reply to placing an item in to a chest
+    """
     _byte_size: int = 0
     _added_item_id: int = None # type: ignore [assignment]
     _remaining_amount: int = None # type: ignore [assignment]
@@ -116,19 +119,23 @@ class ChestReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ChestReplyServerPacket): The data to serialize.
         """
-        if data._added_item_id is None:
-            raise SerializationError("added_item_id must be provided.")
-        writer.add_short(data._added_item_id)
-        if data._remaining_amount is None:
-            raise SerializationError("remaining_amount must be provided.")
-        writer.add_int(data._remaining_amount)
-        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)):
-            ThreeItem.serialize(writer, data._items[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._added_item_id is None:
+                raise SerializationError("added_item_id must be provided.")
+            writer.add_short(data._added_item_id)
+            if data._remaining_amount is None:
+                raise SerializationError("remaining_amount must be provided.")
+            writer.add_int(data._remaining_amount)
+            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)):
+                ThreeItem.serialize(writer, data._items[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ChestReplyServerPacket":

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

@@ -10,6 +10,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ChestSpecServerPacket(Packet):
+    """
+    Reply to trying to add an item to a full chest
+    """
     _byte_size: int = 0
 
     @property
@@ -60,9 +63,11 @@ class ChestSpecServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ChestSpecServerPacket): The data to serialize.
         """
-        old_writer_length: int = len(writer)
-        if len(writer) == old_writer_length:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
             writer.add_byte(0)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ChestSpecServerPacket":
@@ -79,8 +84,7 @@ class ChestSpecServerPacket(Packet):
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            if reader.position == reader_start_position:
-                reader.get_byte()
+            reader.get_byte()
             data._byte_size = reader.position - reader_start_position
             return data
         finally:

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class CitizenAcceptServerPacket(Packet):
+    """
+    Sleeping at an inn
+    """
     _byte_size: int = 0
     _gold_amount: int = None # type: ignore [assignment]
 
@@ -78,9 +81,13 @@ class CitizenAcceptServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CitizenAcceptServerPacket): The data to serialize.
         """
-        if data._gold_amount is None:
-            raise SerializationError("gold_amount must be provided.")
-        writer.add_int(data._gold_amount)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._gold_amount is None:
+                raise SerializationError("gold_amount must be provided.")
+            writer.add_int(data._gold_amount)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CitizenAcceptServerPacket":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class CitizenOpenServerPacket(Packet):
+    """
+    Response from talking to a citizenship NPC
+    """
     _byte_size: int = 0
     _behavior_id: int = None # type: ignore [assignment]
     _current_home_id: int = None # type: ignore [assignment]
@@ -130,24 +133,30 @@ class CitizenOpenServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CitizenOpenServerPacket): The data to serialize.
         """
-        if data._behavior_id is None:
-            raise SerializationError("behavior_id must be provided.")
-        writer.add_three(data._behavior_id)
-        if data._current_home_id is None:
-            raise SerializationError("current_home_id must be provided.")
-        writer.add_char(data._current_home_id)
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_short(data._session_id)
-        writer.add_byte(0xFF)
-        if data._questions is None:
-            raise SerializationError("questions must be provided.")
-        if len(data._questions) != 3:
-            raise SerializationError(f"Expected length of questions to be exactly 3, got {len(data._questions)}.")
-        for i in range(3):
-            if i > 0:
-                writer.add_byte(0xFF)
-            writer.add_string(data._questions[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._behavior_id is None:
+                raise SerializationError("behavior_id must be provided.")
+            writer.add_three(data._behavior_id)
+            if data._current_home_id is None:
+                raise SerializationError("current_home_id must be provided.")
+            writer.add_char(data._current_home_id)
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_short(data._session_id)
+            writer.add_byte(0xFF)
+            if data._questions is None:
+                raise SerializationError("questions must be provided.")
+            if len(data._questions) != 3:
+                raise SerializationError(f"Expected length of questions to be exactly 3, got {len(data._questions)}.")
+            for i in range(3):
+                if i > 0:
+                    writer.add_byte(0xFF)
+                writer.add_string(data._questions[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CitizenOpenServerPacket":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class CitizenRemoveServerPacket(Packet):
+    """
+    Response to giving up citizenship of a town
+    """
     _byte_size: int = 0
     _reply_code: InnUnsubscribeReply = None # type: ignore [assignment]
 
@@ -71,9 +74,13 @@ class CitizenRemoveServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CitizenRemoveServerPacket): The data to serialize.
         """
-        if data._reply_code is None:
-            raise SerializationError("reply_code must be provided.")
-        writer.add_char(int(data._reply_code))
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._reply_code is None:
+                raise SerializationError("reply_code must be provided.")
+            writer.add_char(int(data._reply_code))
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CitizenRemoveServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class CitizenReplyServerPacket(Packet):
+    """
+    Response to subscribing to a town
+    """
     _byte_size: int = 0
     _questions_wrong: int = None # type: ignore [assignment]
 
@@ -78,9 +81,13 @@ class CitizenReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CitizenReplyServerPacket): The data to serialize.
         """
-        if data._questions_wrong is None:
-            raise SerializationError("questions_wrong must be provided.")
-        writer.add_char(data._questions_wrong)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._questions_wrong is None:
+                raise SerializationError("questions_wrong must be provided.")
+            writer.add_char(data._questions_wrong)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CitizenReplyServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class CitizenRequestServerPacket(Packet):
+    """
+    Reply to requesting sleeping at an inn
+    """
     _byte_size: int = 0
     _cost: int = None # type: ignore [assignment]
 
@@ -78,9 +81,13 @@ class CitizenRequestServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CitizenRequestServerPacket): The data to serialize.
         """
-        if data._cost is None:
-            raise SerializationError("cost must be provided.")
-        writer.add_int(data._cost)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._cost is None:
+                raise SerializationError("cost must be provided.")
+            writer.add_int(data._cost)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CitizenRequestServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ConnectionPlayerServerPacket(Packet):
+    """
+    Ping request
+    """
     _byte_size: int = 0
     _seq1: int = None # type: ignore [assignment]
     _seq2: int = None # type: ignore [assignment]
@@ -95,12 +98,16 @@ class ConnectionPlayerServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ConnectionPlayerServerPacket): The data to serialize.
         """
-        if data._seq1 is None:
-            raise SerializationError("seq1 must be provided.")
-        writer.add_short(data._seq1)
-        if data._seq2 is None:
-            raise SerializationError("seq2 must be provided.")
-        writer.add_char(data._seq2)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._seq1 is None:
+                raise SerializationError("seq1 must be provided.")
+            writer.add_short(data._seq1)
+            if data._seq2 is None:
+                raise SerializationError("seq2 must be provided.")
+            writer.add_char(data._seq2)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ConnectionPlayerServerPacket":

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

@@ -64,16 +64,20 @@ class DialogEntry:
             writer (EoWriter): The writer that the data will be serialized to.
             data (DialogEntry): The data to serialize.
         """
-        if data._entry_type is None:
-            raise SerializationError("entry_type must be provided.")
-        writer.add_short(int(data._entry_type))
-        if data._entry_type == DialogEntryType.Link:
-            if not isinstance(data._entry_type_data, DialogEntry.EntryTypeDataLink):
-                raise SerializationError("Expected entry_type_data to be type DialogEntry.EntryTypeDataLink for entry_type " + DialogEntryType(data._entry_type).name + ".")
-            DialogEntry.EntryTypeDataLink.serialize(writer, data._entry_type_data)
-        if data._line is None:
-            raise SerializationError("line must be provided.")
-        writer.add_string(data._line)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._entry_type is None:
+                raise SerializationError("entry_type must be provided.")
+            writer.add_short(int(data._entry_type))
+            if data._entry_type == DialogEntryType.Link:
+                if not isinstance(data._entry_type_data, DialogEntry.EntryTypeDataLink):
+                    raise SerializationError("Expected entry_type_data to be type DialogEntry.EntryTypeDataLink for entry_type " + DialogEntryType(data._entry_type).name + ".")
+                DialogEntry.EntryTypeDataLink.serialize(writer, data._entry_type_data)
+            if data._line is None:
+                raise SerializationError("line must be provided.")
+            writer.add_string(data._line)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "DialogEntry":
@@ -103,10 +107,9 @@ class DialogEntry:
         return f"DialogEntry(byte_size={repr(self._byte_size)}, entry_type={repr(self._entry_type)}, entry_type_data={repr(self._entry_type_data)}, line={repr(self._line)})"
 
     EntryTypeData = Union['DialogEntry.EntryTypeDataLink', None]
-    EntryTypeData.__doc__ = \
-        """
-        Data associated with different values of the `entry_type` field.
-        """
+    """
+    Data associated with different values of the `entry_type` field.
+    """
 
     class EntryTypeDataLink:
         """
@@ -150,9 +153,13 @@ class DialogEntry:
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (DialogEntry.EntryTypeDataLink): The data to serialize.
             """
-            if data._link_id is None:
-                raise SerializationError("link_id must be provided.")
-            writer.add_short(data._link_id)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._link_id is None:
+                    raise SerializationError("link_id must be provided.")
+                writer.add_short(data._link_id)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "DialogEntry.EntryTypeDataLink":