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

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

@@ -4,6 +4,7 @@
 # Changes will be lost when code is regenerated.
 
 from __future__ import annotations
+from collections.abc import Iterable
 from ..three_item import ThreeItem
 from ..packet_family import PacketFamily
 from ..packet_action import PacketAction
@@ -18,8 +19,19 @@ class LockerOpenServerPacket(Packet):
     Opening a bank locker
     """
     _byte_size: int = 0
-    _locker_coords: Coords = None # type: ignore [assignment]
-    _locker_items: list[ThreeItem] = None # type: ignore [assignment]
+    _locker_coords: Coords
+    _locker_items: tuple[ThreeItem, ...]
+
+    def __init__(self, *, locker_coords: Coords, locker_items: Iterable[ThreeItem]):
+        """
+        Create a new instance of LockerOpenServerPacket.
+
+        Args:
+            locker_coords (Coords): 
+            locker_items (Iterable[ThreeItem]): 
+        """
+        self._locker_coords = locker_coords
+        self._locker_items = tuple(locker_items)
 
     @property
     def byte_size(self) -> int:
@@ -35,18 +47,10 @@ class LockerOpenServerPacket(Packet):
     def locker_coords(self) -> Coords:
         return self._locker_coords
 
-    @locker_coords.setter
-    def locker_coords(self, locker_coords: Coords) -> None:
-        self._locker_coords = locker_coords
-
     @property
-    def locker_items(self) -> list[ThreeItem]:
+    def locker_items(self) -> tuple[ThreeItem, ...]:
         return self._locker_items
 
-    @locker_items.setter
-    def locker_items(self, locker_items: list[ThreeItem]) -> None:
-        self._locker_items = locker_items
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -108,17 +112,17 @@ class LockerOpenServerPacket(Packet):
         Returns:
             LockerOpenServerPacket: The data to serialize.
         """
-        data: LockerOpenServerPacket = LockerOpenServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._locker_coords = Coords.deserialize(reader)
+            locker_coords = Coords.deserialize(reader)
             locker_items_length = int(reader.remaining / 5)
-            data._locker_items = []
+            locker_items = []
             for i in range(locker_items_length):
-                data._locker_items.append(ThreeItem.deserialize(reader))
-            data._byte_size = reader.position - reader_start_position
-            return data
+                locker_items.append(ThreeItem.deserialize(reader))
+            result = LockerOpenServerPacket(locker_coords=locker_coords, locker_items=locker_items)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -4,6 +4,7 @@
 # Changes will be lost when code is regenerated.
 
 from __future__ import annotations
+from collections.abc import Iterable
 from ..weight import Weight
 from ..three_item import ThreeItem
 from ..packet_family import PacketFamily
@@ -19,9 +20,22 @@ class LockerReplyServerPacket(Packet):
     Response to adding an item to a bank locker
     """
     _byte_size: int = 0
-    _deposited_item: Item = None # type: ignore [assignment]
-    _weight: Weight = None # type: ignore [assignment]
-    _locker_items: list[ThreeItem] = None # type: ignore [assignment]
+    _deposited_item: Item
+    _weight: Weight
+    _locker_items: tuple[ThreeItem, ...]
+
+    def __init__(self, *, deposited_item: Item, weight: Weight, locker_items: Iterable[ThreeItem]):
+        """
+        Create a new instance of LockerReplyServerPacket.
+
+        Args:
+            deposited_item (Item): 
+            weight (Weight): 
+            locker_items (Iterable[ThreeItem]): 
+        """
+        self._deposited_item = deposited_item
+        self._weight = weight
+        self._locker_items = tuple(locker_items)
 
     @property
     def byte_size(self) -> int:
@@ -37,26 +51,14 @@ class LockerReplyServerPacket(Packet):
     def deposited_item(self) -> Item:
         return self._deposited_item
 
-    @deposited_item.setter
-    def deposited_item(self, deposited_item: Item) -> None:
-        self._deposited_item = deposited_item
-
     @property
     def weight(self) -> Weight:
         return self._weight
 
-    @weight.setter
-    def weight(self, weight: Weight) -> None:
-        self._weight = weight
-
     @property
-    def locker_items(self) -> list[ThreeItem]:
+    def locker_items(self) -> tuple[ThreeItem, ...]:
         return self._locker_items
 
-    @locker_items.setter
-    def locker_items(self, locker_items: list[ThreeItem]) -> None:
-        self._locker_items = locker_items
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -121,18 +123,18 @@ class LockerReplyServerPacket(Packet):
         Returns:
             LockerReplyServerPacket: The data to serialize.
         """
-        data: LockerReplyServerPacket = LockerReplyServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._deposited_item = Item.deserialize(reader)
-            data._weight = Weight.deserialize(reader)
+            deposited_item = Item.deserialize(reader)
+            weight = Weight.deserialize(reader)
             locker_items_length = int(reader.remaining / 5)
-            data._locker_items = []
+            locker_items = []
             for i in range(locker_items_length):
-                data._locker_items.append(ThreeItem.deserialize(reader))
-            data._byte_size = reader.position - reader_start_position
-            return data
+                locker_items.append(ThreeItem.deserialize(reader))
+            result = LockerReplyServerPacket(deposited_item=deposited_item, weight=weight, locker_items=locker_items)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -15,7 +15,16 @@ class LockerSpecServerPacket(Packet):
     Reply to trying to add an item to a full locker
     """
     _byte_size: int = 0
-    _locker_max_items: int = None # type: ignore [assignment]
+    _locker_max_items: int
+
+    def __init__(self, *, locker_max_items: int):
+        """
+        Create a new instance of LockerSpecServerPacket.
+
+        Args:
+            locker_max_items (int): (Value range is 0-252.)
+        """
+        self._locker_max_items = locker_max_items
 
     @property
     def byte_size(self) -> int:
@@ -29,20 +38,8 @@ class LockerSpecServerPacket(Packet):
 
     @property
     def locker_max_items(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._locker_max_items
 
-    @locker_max_items.setter
-    def locker_max_items(self, locker_max_items: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._locker_max_items = locker_max_items
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -100,13 +97,13 @@ class LockerSpecServerPacket(Packet):
         Returns:
             LockerSpecServerPacket: The data to serialize.
         """
-        data: LockerSpecServerPacket = LockerSpecServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._locker_max_items = reader.get_char()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            locker_max_items = reader.get_char()
+            result = LockerSpecServerPacket(locker_max_items=locker_max_items)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 from typing import Union
+from collections.abc import Iterable
 from .login_reply import LoginReply
 from .character_selection_list_entry import CharacterSelectionListEntry
 from ..packet_family import PacketFamily
@@ -19,8 +20,19 @@ class LoginReplyServerPacket(Packet):
     Login reply
     """
     _byte_size: int = 0
-    _reply_code: LoginReply = None # type: ignore [assignment]
-    _reply_code_data: 'LoginReplyServerPacket.ReplyCodeData' = None
+    _reply_code: LoginReply
+    _reply_code_data: 'LoginReplyServerPacket.ReplyCodeData'
+
+    def __init__(self, *, reply_code: LoginReply, reply_code_data: 'LoginReplyServerPacket.ReplyCodeData' = None):
+        """
+        Create a new instance of LoginReplyServerPacket.
+
+        Args:
+            reply_code (LoginReply): 
+            reply_code_data (LoginReplyServerPacket.ReplyCodeData): Data associated with the `reply_code` field.
+        """
+        self._reply_code = reply_code
+        self._reply_code_data = reply_code_data
 
     @property
     def byte_size(self) -> int:
@@ -36,21 +48,13 @@ class LoginReplyServerPacket(Packet):
     def reply_code(self) -> LoginReply:
         return self._reply_code
 
-    @reply_code.setter
-    def reply_code(self, reply_code: LoginReply) -> None:
-        self._reply_code = reply_code
-
     @property
     def reply_code_data(self) -> 'LoginReplyServerPacket.ReplyCodeData':
         """
-        LoginReplyServerPacket.ReplyCodeData: Gets or sets the data associated with the `reply_code` field.
+        LoginReplyServerPacket.ReplyCodeData: Data associated with the `reply_code` field.
         """
         return self._reply_code_data
 
-    @reply_code_data.setter
-    def reply_code_data(self, reply_code_data: 'LoginReplyServerPacket.ReplyCodeData') -> None:
-        self._reply_code_data = reply_code_data
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -134,27 +138,28 @@ class LoginReplyServerPacket(Packet):
         Returns:
             LoginReplyServerPacket: The data to serialize.
         """
-        data: LoginReplyServerPacket = LoginReplyServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
-            data._reply_code = LoginReply(reader.get_short())
-            if data._reply_code == LoginReply.WrongUser:
-                data._reply_code_data = LoginReplyServerPacket.ReplyCodeDataWrongUser.deserialize(reader)
-            elif data._reply_code == LoginReply.WrongUserPassword:
-                data._reply_code_data = LoginReplyServerPacket.ReplyCodeDataWrongUserPassword.deserialize(reader)
-            elif data._reply_code == LoginReply.Ok:
-                data._reply_code_data = LoginReplyServerPacket.ReplyCodeDataOk.deserialize(reader)
-            elif data._reply_code == LoginReply.Banned:
-                data._reply_code_data = LoginReplyServerPacket.ReplyCodeDataBanned.deserialize(reader)
-            elif data._reply_code == LoginReply.LoggedIn:
-                data._reply_code_data = LoginReplyServerPacket.ReplyCodeDataLoggedIn.deserialize(reader)
-            elif data._reply_code == LoginReply.Busy:
-                data._reply_code_data = LoginReplyServerPacket.ReplyCodeDataBusy.deserialize(reader)
+            reply_code = LoginReply(reader.get_short())
+            reply_code_data: LoginReplyServerPacket.ReplyCodeData = None
+            if reply_code == LoginReply.WrongUser:
+                reply_code_data = LoginReplyServerPacket.ReplyCodeDataWrongUser.deserialize(reader)
+            elif reply_code == LoginReply.WrongUserPassword:
+                reply_code_data = LoginReplyServerPacket.ReplyCodeDataWrongUserPassword.deserialize(reader)
+            elif reply_code == LoginReply.Ok:
+                reply_code_data = LoginReplyServerPacket.ReplyCodeDataOk.deserialize(reader)
+            elif reply_code == LoginReply.Banned:
+                reply_code_data = LoginReplyServerPacket.ReplyCodeDataBanned.deserialize(reader)
+            elif reply_code == LoginReply.LoggedIn:
+                reply_code_data = LoginReplyServerPacket.ReplyCodeDataLoggedIn.deserialize(reader)
+            elif reply_code == LoginReply.Busy:
+                reply_code_data = LoginReplyServerPacket.ReplyCodeDataBusy.deserialize(reader)
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = LoginReplyServerPacket(reply_code=reply_code, reply_code_data=reply_code_data)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -172,6 +177,11 @@ class LoginReplyServerPacket(Packet):
         """
         _byte_size: int = 0
 
+        def __init__(self):
+            """
+            Create a new instance of LoginReplyServerPacket.ReplyCodeDataWrongUser.
+            """
+
         @property
         def byte_size(self) -> int:
             """
@@ -209,13 +219,13 @@ class LoginReplyServerPacket(Packet):
             Returns:
                 LoginReplyServerPacket.ReplyCodeDataWrongUser: The data to serialize.
             """
-            data: LoginReplyServerPacket.ReplyCodeDataWrongUser = LoginReplyServerPacket.ReplyCodeDataWrongUser()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
                 reader.get_string()
-                data._byte_size = reader.position - reader_start_position
-                return data
+                result = LoginReplyServerPacket.ReplyCodeDataWrongUser()
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -228,6 +238,11 @@ class LoginReplyServerPacket(Packet):
         """
         _byte_size: int = 0
 
+        def __init__(self):
+            """
+            Create a new instance of LoginReplyServerPacket.ReplyCodeDataWrongUserPassword.
+            """
+
         @property
         def byte_size(self) -> int:
             """
@@ -265,13 +280,13 @@ class LoginReplyServerPacket(Packet):
             Returns:
                 LoginReplyServerPacket.ReplyCodeDataWrongUserPassword: The data to serialize.
             """
-            data: LoginReplyServerPacket.ReplyCodeDataWrongUserPassword = LoginReplyServerPacket.ReplyCodeDataWrongUserPassword()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
                 reader.get_string()
-                data._byte_size = reader.position - reader_start_position
-                return data
+                result = LoginReplyServerPacket.ReplyCodeDataWrongUserPassword()
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -283,8 +298,18 @@ class LoginReplyServerPacket(Packet):
         Data associated with reply_code value LoginReply.Ok
         """
         _byte_size: int = 0
-        _characters_count: int = None # type: ignore [assignment]
-        _characters: list[CharacterSelectionListEntry] = None # type: ignore [assignment]
+        _characters_count: int
+        _characters: tuple[CharacterSelectionListEntry, ...]
+
+        def __init__(self, *, characters: Iterable[CharacterSelectionListEntry]):
+            """
+            Create a new instance of LoginReplyServerPacket.ReplyCodeDataOk.
+
+            Args:
+                characters (Iterable[CharacterSelectionListEntry]): (Length must be 252 or less.)
+            """
+            self._characters = tuple(characters)
+            self._characters_count = len(self._characters)
 
         @property
         def byte_size(self) -> int:
@@ -297,22 +322,9 @@ class LoginReplyServerPacket(Packet):
             return self._byte_size
 
         @property
-        def characters(self) -> list[CharacterSelectionListEntry]:
-            """
-            Note:
-              - Length must be 252 or less.
-            """
+        def characters(self) -> tuple[CharacterSelectionListEntry, ...]:
             return self._characters
 
-        @characters.setter
-        def characters(self, characters: list[CharacterSelectionListEntry]) -> None:
-            """
-            Note:
-              - Length must be 252 or less.
-            """
-            self._characters = characters
-            self._characters_count = len(self._characters)
-
         @staticmethod
         def serialize(writer: EoWriter, data: "LoginReplyServerPacket.ReplyCodeDataOk") -> None:
             """
@@ -350,19 +362,19 @@ class LoginReplyServerPacket(Packet):
             Returns:
                 LoginReplyServerPacket.ReplyCodeDataOk: The data to serialize.
             """
-            data: LoginReplyServerPacket.ReplyCodeDataOk = LoginReplyServerPacket.ReplyCodeDataOk()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._characters_count = reader.get_char()
+                characters_count = reader.get_char()
                 reader.get_char()
                 reader.next_chunk()
-                data._characters = []
-                for i in range(data._characters_count):
-                    data._characters.append(CharacterSelectionListEntry.deserialize(reader))
+                characters = []
+                for i in range(characters_count):
+                    characters.append(CharacterSelectionListEntry.deserialize(reader))
                     reader.next_chunk()
-                data._byte_size = reader.position - reader_start_position
-                return data
+                result = LoginReplyServerPacket.ReplyCodeDataOk(characters=characters)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -375,6 +387,11 @@ class LoginReplyServerPacket(Packet):
         """
         _byte_size: int = 0
 
+        def __init__(self):
+            """
+            Create a new instance of LoginReplyServerPacket.ReplyCodeDataBanned.
+            """
+
         @property
         def byte_size(self) -> int:
             """
@@ -412,13 +429,13 @@ class LoginReplyServerPacket(Packet):
             Returns:
                 LoginReplyServerPacket.ReplyCodeDataBanned: The data to serialize.
             """
-            data: LoginReplyServerPacket.ReplyCodeDataBanned = LoginReplyServerPacket.ReplyCodeDataBanned()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
                 reader.get_string()
-                data._byte_size = reader.position - reader_start_position
-                return data
+                result = LoginReplyServerPacket.ReplyCodeDataBanned()
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -431,6 +448,11 @@ class LoginReplyServerPacket(Packet):
         """
         _byte_size: int = 0
 
+        def __init__(self):
+            """
+            Create a new instance of LoginReplyServerPacket.ReplyCodeDataLoggedIn.
+            """
+
         @property
         def byte_size(self) -> int:
             """
@@ -468,13 +490,13 @@ class LoginReplyServerPacket(Packet):
             Returns:
                 LoginReplyServerPacket.ReplyCodeDataLoggedIn: The data to serialize.
             """
-            data: LoginReplyServerPacket.ReplyCodeDataLoggedIn = LoginReplyServerPacket.ReplyCodeDataLoggedIn()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
                 reader.get_string()
-                data._byte_size = reader.position - reader_start_position
-                return data
+                result = LoginReplyServerPacket.ReplyCodeDataLoggedIn()
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -487,6 +509,11 @@ class LoginReplyServerPacket(Packet):
         """
         _byte_size: int = 0
 
+        def __init__(self):
+            """
+            Create a new instance of LoginReplyServerPacket.ReplyCodeDataBusy.
+            """
+
         @property
         def byte_size(self) -> int:
             """
@@ -524,13 +551,13 @@ class LoginReplyServerPacket(Packet):
             Returns:
                 LoginReplyServerPacket.ReplyCodeDataBusy: The data to serialize.
             """
-            data: LoginReplyServerPacket.ReplyCodeDataBusy = LoginReplyServerPacket.ReplyCodeDataBusy()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
                 reader.get_string()
-                data._byte_size = reader.position - reader_start_position
-                return data
+                result = LoginReplyServerPacket.ReplyCodeDataBusy()
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -12,9 +12,22 @@ class MapDrainDamageOther:
     Another player taking damage from a map HP drain
     """
     _byte_size: int = 0
-    _player_id: int = None # type: ignore [assignment]
-    _hp_percentage: int = None # type: ignore [assignment]
-    _damage: int = None # type: ignore [assignment]
+    _player_id: int
+    _hp_percentage: int
+    _damage: int
+
+    def __init__(self, *, player_id: int, hp_percentage: int, damage: int):
+        """
+        Create a new instance of MapDrainDamageOther.
+
+        Args:
+            player_id (int): (Value range is 0-64008.)
+            hp_percentage (int): (Value range is 0-252.)
+            damage (int): (Value range is 0-64008.)
+        """
+        self._player_id = player_id
+        self._hp_percentage = hp_percentage
+        self._damage = damage
 
     @property
     def byte_size(self) -> int:
@@ -28,52 +41,16 @@ class MapDrainDamageOther:
 
     @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 hp_percentage(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._hp_percentage
 
-    @hp_percentage.setter
-    def hp_percentage(self, hp_percentage: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._hp_percentage = hp_percentage
-
     @property
     def damage(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._damage
 
-    @damage.setter
-    def damage(self, damage: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._damage = damage
-
     @staticmethod
     def serialize(writer: EoWriter, data: "MapDrainDamageOther") -> None:
         """
@@ -108,15 +85,15 @@ class MapDrainDamageOther:
         Returns:
             MapDrainDamageOther: The data to serialize.
         """
-        data: MapDrainDamageOther = MapDrainDamageOther()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._player_id = reader.get_short()
-            data._hp_percentage = reader.get_char()
-            data._damage = reader.get_short()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            player_id = reader.get_short()
+            hp_percentage = reader.get_char()
+            damage = reader.get_short()
+            result = MapDrainDamageOther(player_id=player_id, hp_percentage=hp_percentage, damage=damage)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -12,7 +12,16 @@ class MapFile:
     A map file (EMF)
     """
     _byte_size: int = 0
-    _content: bytes = None # type: ignore [assignment]
+    _content: bytes
+
+    def __init__(self, *, content: bytes):
+        """
+        Create a new instance of MapFile.
+
+        Args:
+            content (bytes): 
+        """
+        self._content = content
 
     @property
     def byte_size(self) -> int:
@@ -28,10 +37,6 @@ class MapFile:
     def content(self) -> bytes:
         return self._content
 
-    @content.setter
-    def content(self, content: bytes) -> None:
-        self._content = content
-
     @staticmethod
     def serialize(writer: EoWriter, data: "MapFile") -> None:
         """
@@ -60,13 +65,13 @@ class MapFile:
         Returns:
             MapFile: The data to serialize.
         """
-        data: MapFile = MapFile()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._content = reader.get_bytes(reader.remaining)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            content = reader.get_bytes(reader.remaining)
+            result = MapFile(content=content)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode