arkparse 0.2.2__tar.gz → 0.2.4__tar.gz

{arkparse-0.2.2 → arkparse-0.2.4}/.gitignore

@@ -85,6 +85,7 @@ ipython_config.py
 
 **/binary-reader/**
 src/binary_reader/
+tests/temp**
 
 # pyenv
 #   For a library or package, you might want to ignore these files since the code is

{arkparse-0.2.2 → arkparse-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arkparse
-Version: 0.2.2
+Version: 0.2.4
 Summary: A package to parse and modify ark save files
 Project-URL: Homepage, https://github.com/VincentHenauGithub/ark-save-parser
 Author-email: Vincent Henau <vincent.henau.github@gmail.com>

{arkparse-0.2.2 → arkparse-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "arkparse"
-version = "0.2.2"
+version = "0.2.4"
 dependencies = [
     "pytz>=2025.2",
     "rcon>=2.4.9",

{arkparse-0.2.2 → arkparse-0.2.4}/src/arkparse/api/base_api.py

@@ -15,6 +15,7 @@ from arkparse.parsing.struct import ActorTransform
 from arkparse.parsing import ArkBinaryParser
 from arkparse.object_model import ArkGameObject
 from arkparse.utils import ImportFile
+from arkparse.logging import ArkSaveLogger
 
 class BaseApi(StructureApi):
     def __init__(self, save, map: ArkMap):
@@ -33,8 +34,8 @@ class BaseApi(StructureApi):
                 closest_dist = dist
 
         return closest
-
-    def get_base_at(self, coords: MapCoords, radius: float = 0.3, owner_tribe_id = None) -> Base:
+    
+    def get_base_at(self, coords: MapCoords, radius: float = 0.3, owner_tribe_id = None, keystone: Structure = None) -> Base:
         structures = self.get_at_location(self.map, coords, radius)
         if structures is None or len(structures) == 0:
             return None
@@ -50,10 +51,9 @@ class BaseApi(StructureApi):
         if owner_tribe_id is not None:
             all_structures = {k: v for k, v in all_structures.items() if v.owner.tribe_id == owner_tribe_id}
 
-        keystone = self.__get_closest_to(all_structures, coords)
-
+        if keystone is None:
+            keystone = self.__get_closest_to(all_structures, coords)
         keystone_owner = keystone.owner if keystone is not None else None
-
         filtered_structures = {k: v for k, v in all_structures.items() if v.owner == keystone_owner}
 
         return Base(keystone.object.uuid, filtered_structures) if keystone is not None else None
@@ -168,6 +168,30 @@ class BaseApi(StructureApi):
             base.move_to(location, self.save)
 
         return base
+    
+    def get_all_bases(self, only_connected: bool = False, radius: float = 0.3) -> List[Base]:
+        all_bases: List[Base] = []
+        all_structures: Dict[UUID, Structure] = super().get_all()
+        visited_structures: List[UUID] = []
+
+        for key, structure in all_structures.items():
+            base = None
+            if key in visited_structures:
+                continue
+    
+            if only_connected:
+                connected = self.get_connected_structures({key: structure})
+                base = Base(structure.uuid, connected)
+                all_bases.append(base)
+            else:
+                base = self.get_base_at(structure.location.as_map_coords(self.map), radius, structure.owner.tribe_id, structure)
+
+            for structure in base.structures.values():
+                visited_structures.append(structure.uuid)
+
+            ArkSaveLogger.api_log(f"Parsed base at {'Unknown' if base.location is None else base.keystone.location.as_map_coords(self.map)} with {len(base.structures)} structures, owner: {base.owner}")
+
+        return all_bases
 
                 
 

{arkparse-0.2.2 → arkparse-0.2.4}/src/arkparse/api/dino_api.py

@@ -81,66 +81,69 @@ class DinoApi:
 
         ArkSaveLogger.api_log(f"Found {len(objects)} dinos, parsing them... (and retrieving inventories)")
         for key, obj in objects.items():
-            dino = None
-            if "Dinos/" in obj.blueprint and "_Character_" in obj.blueprint:
-                is_tamed = obj.get_property_value("TamedTimeStamp") is not None
-                is_baby = obj.get_property_value("bIsBaby", False)
 
-                if obj.uuid in self.parsed_dinos:
-                    if is_tamed and include_tamed:
+            try:
+                dino = None
+                if "Dinos/" in obj.blueprint and "_Character_" in obj.blueprint:
+                    is_tamed = obj.get_property_value("TamedTimeStamp") is not None
+                    is_baby = obj.get_property_value("bIsBaby", False)
+
+                    if obj.uuid in self.parsed_dinos:
+                        if is_tamed and include_tamed:
+                            if is_baby and include_babies:
+                                dino = self.parsed_dinos[obj.uuid]
+                            else:
+                                dino = self.parsed_dinos[obj.uuid]
+                        elif not is_tamed and include_wild:
+                            if is_baby and include_babies:
+                                dino = self.parsed_dinos[obj.uuid]
+                            else:
+                                dino = self.parsed_dinos[obj.uuid]
+                    elif is_tamed and include_tamed:
                         if is_baby and include_babies:
-                            dino = self.parsed_dinos[obj.uuid]
+                            dino = TamedBaby(obj.uuid, save=self.save)
                         else:
-                            dino = self.parsed_dinos[obj.uuid]
-                    elif not is_tamed and include_wild:
+                            dino = TamedDino(obj.uuid, save=self.save)
+                        self.parsed_dinos[obj.uuid] = dino
+                    elif include_wild and not is_tamed:
                         if is_baby and include_babies:
-                            dino = self.parsed_dinos[obj.uuid]
+                            dino = Baby(obj.uuid, save=self.save)
                         else:
-                            dino = self.parsed_dinos[obj.uuid]
-                elif is_tamed and include_tamed:
-                    if is_baby and include_babies:
-                        dino = TamedBaby(obj.uuid, save=self.save)
-                    else:
-                        dino = TamedDino(obj.uuid, save=self.save)
-                    self.parsed_dinos[obj.uuid] = dino
-                elif include_wild and not is_tamed:
-                    if is_baby and include_babies:
-                        dino = Baby(obj.uuid, save=self.save)
-                    else:
-                        dino = Dino(obj.uuid, save=self.save)
-                    self.parsed_dinos[obj.uuid] = dino
-
-            elif "PrimalItem_WeaponEmptyCryopod_C" in obj.blueprint and include_cryos and include_tamed:
-                if not obj.get_property_value("bIsEngram", default=False):
-                    if obj.uuid in self.parsed_cryopods:
-                        is_baby = self.parsed_cryopods[obj.uuid].dino is not None and isinstance(self.parsed_cryopods[obj.uuid].dino, TamedBaby)
-                        if is_baby and include_babies:
-                            dino = self.parsed_cryopods[obj.uuid].dino
+                            dino = Dino(obj.uuid, save=self.save)
+                        self.parsed_dinos[obj.uuid] = dino
+
+                elif "PrimalItem_WeaponEmptyCryopod_C" in obj.blueprint and include_cryos and include_tamed:
+                    if not obj.get_property_value("bIsEngram", default=False):
+                        if obj.uuid in self.parsed_cryopods:
+                            is_baby = self.parsed_cryopods[obj.uuid].dino is not None and isinstance(self.parsed_cryopods[obj.uuid].dino, TamedBaby)
+                            if is_baby and include_babies:
+                                dino = self.parsed_cryopods[obj.uuid].dino
+                            else:
+                                dino = self.parsed_cryopods[obj.uuid].dino
                         else:
-                            dino = self.parsed_cryopods[obj.uuid].dino
-                    else:
-                        try:
-                            cryopod = Cryopod(obj.uuid, save=self.save)
-                            self.parsed_cryopods[obj.uuid] = cryopod
-                            if cryopod.dino is not None:
-                                dino = cryopod.dino
-                                dino.is_cryopodded = True
-                        except Exception as e:
-                            if "Unsupported embedded data version" in str(e):
-                                ArkSaveLogger.warning_log(f"Skipping cryopod {obj.uuid} due to unsupported embedded data version (pre Unreal 5.5)")
-                                continue
-                            ArkSaveLogger.set_log_level(ArkSaveLogger.LogTypes.PARSER, True)
-                            parser = ArkBinaryParser(self.save.get_game_obj_binary(obj.uuid), self.save.save_context)
-                            cryopod = Cryopod(obj.uuid, parser)
-                            ArkSaveLogger.set_log_level(ArkSaveLogger.LogTypes.PARSER, False)
-                            ArkSaveLogger.error_log(f"Error parsing cryopod {obj.uuid}: {e}")
-
-                            if ArkSaveLogger._allow_invalid_objects:
-                                continue
-                            raise e
-            
-            if dino is not None:
-                dinos[key] = dino
+                            try:
+                                cryopod = Cryopod(obj.uuid, save=self.save)
+                                self.parsed_cryopods[obj.uuid] = cryopod
+                                if cryopod.dino is not None:
+                                    dino = cryopod.dino
+                                    dino.is_cryopodded = True
+                            except Exception as e:
+                                if "Unsupported embedded data version" in str(e):
+                                    ArkSaveLogger.warning_log(f"Skipping cryopod {obj.uuid} due to unsupported embedded data version (pre Unreal 5.5)")
+                                    continue
+                                ArkSaveLogger.set_log_level(ArkSaveLogger.LogTypes.PARSER, True)
+                                cryopod = Cryopod(obj.uuid, save=self.save)
+                                ArkSaveLogger.set_log_level(ArkSaveLogger.LogTypes.PARSER, False)
+                                ArkSaveLogger.error_log(f"Error parsing cryopod {obj.uuid}: {e}")
+                                raise e
+                
+                if dino is not None:
+                    dinos[key] = dino
+            except Exception as e:
+                if ArkSaveLogger._allow_invalid_objects:
+                    ArkSaveLogger.error_log(f"Failed to parse dino {obj.uuid}: {e}")
+                else:
+                    raise e
 
         ArkSaveLogger.api_log(f"Parsed {len(dinos)} dinos")
 
@@ -391,15 +394,15 @@ class DinoApi:
         return np.array(heatmap)
     
     
-    def get_best_dino_for_stat(self, classes: List[str] = None, stat: ArkStat = None, only_tamed: bool = False, only_untamed: bool = False, base_stat: bool = False, mutated_stat=False) -> (Dino, int, ArkStat):
+    def get_best_dino_for_stat(self, classes: List[str] = None, stat: ArkStat = None, only_tamed: bool = False, only_untamed: bool = False, base_stat: bool = False, mutated_stat=False, level_upper_bound=None) -> (Dino, int, ArkStat):
         if only_tamed and only_untamed:
             raise ValueError("Cannot specify both only_tamed and only_untamed")
         
         if mutated_stat and base_stat:
             raise ValueError("Cannot specify both base_stat and base_mutated_stat")
         
-        if classes is not None:
-            dinos = self.get_all_filtered(class_names=classes, include_cryopodded=True)
+        if classes is not None or level_upper_bound is not None:
+            dinos = self.get_all_filtered(class_names=classes, include_cryopodded=True, level_upper_bound=level_upper_bound)
         else:
             dinos = self.get_all()
 
@@ -450,8 +453,8 @@ class DinoApi:
                 if file_path.name.endswith(".bin") or file_path.name.startswith("loc_"):
                     out.append(ImportFile(str(file_path)))
         return out
-    
-    def import_dino(self, path: Path, location: ActorTransform = None) -> Dino:
+
+    def import_dino(self, path: Path, location: ActorTransform = None) -> Dino | TamedDino:
         uuid_translation_map = {}
 
         def replace_uuids(uuid_map: Dict[UUID, UUID], bytes_: bytes):
@@ -494,6 +497,7 @@ class DinoApi:
                 ArkSaveLogger.api_log(f"Added inventory item {item.uuid} to DB")
 
         # Get inventory and add to DB
+        inventory = None
         for file in files:
             if file.type == "inv":
                 new_uuid = uuid_translation_map[file.uuid]
@@ -515,8 +519,6 @@ class DinoApi:
                 self.save.add_obj_to_db(new_uuid, parser.byte_buffer)
                 stats = DinoStats(uuid=new_uuid, save=self.save)
                 stats.reidentify(new_uuid)
-                stats.binary.replace_boolean(stats.object.find_property("bServerFirstInitialized"), False)
-                self.save.modify_game_obj(stats.object.uuid, stats.binary.byte_buffer)
                 ArkSaveLogger.api_log(f"Added dino stats {stats.uuid} to DB")
 
         # Get AI controller and add to DB
@@ -546,16 +548,16 @@ class DinoApi:
                 if location is not None:
                     dino.set_location(location)
 
-                dino.binary.replace_boolean(dino.object.find_property("bServerInitializedDino"), False)
-                # dino.binary.replace_boolean(dino.object.find_property("bSavedWhenStasised"), False)
-                # dino.binary.replace_u32(dino.object.find_property("TamingTeamID"), 1466169314)
-                # dino.binary.replace_u32(dino.object.find_property("TargetingTeam"), 1466169314)
-                # dino.binary.replace_u32(dino.object.find_property("OwningPlayerID"), 290175622)
-                dino.update_binary()
-
                 ArkSaveLogger.api_log(f"Replacing name \"{dino.stats.object.names[1]}\" with \"{dino.object.names[0]}\"")
                 dino.stats.replace_name_at_index_with(1, dino.object.names[0])
                 dino.stats.update_binary()
+                
+                if inventory is not None:
+                    ArkSaveLogger.api_log(f"Replacing inventory name \"{inventory.object.names[1]}\" with \"{dino.object.names[0]}\"")
+                    inventory.replace_name_at_index_with(1, dino.object.names[0])
+                    inventory.update_binary()
+                    dino: TamedDino = TamedDino(uuid=new_uuid, save=self.save)
+                    return dino
 
                 return dino
 

{arkparse-0.2.2 → arkparse-0.2.4}/src/arkparse/api/equipment_api.py

@@ -201,7 +201,7 @@ class EquipmentApi(GeneralApi):
             elif random_value > range_max*1.5:
                 random_value = int(range_max*1.5)
 
-            ArkSaveLogger.api_log(f"Setting {stat} to {random_value} for {equipment.class_name} {"(used normal distribution)" if normal_distribution else "(used uniform distribution)"}")
+            ArkSaveLogger.api_log(f"Setting {stat} to {random_value} for {equipment.class_name} {'(used normal distribution)' if normal_distribution else '(used uniform distribution)'}")
             equipment.set_stat(stat, equipment.get_actual_value(stat, random_value))
 
         equipment.auto_rate()

{arkparse-0.2.2 → arkparse-0.2.4}/src/arkparse/api/general_api.py

@@ -1,6 +1,7 @@
 from typing import Dict
 from uuid import UUID
 
+from arkparse.logging.ark_save_logger import ArkSaveLogger
 from arkparse.object_model.ark_game_object import ArkGameObject
 from arkparse.parsing import ArkBinaryParser
 from arkparse.saves.asa_save import AsaSave
@@ -39,11 +40,17 @@ class GeneralApi:
             if valid_filter and not valid_filter(obj):
                 continue
 
-            if key in self.parsed_objects:
-                parsed[key] = self.parsed_objects[key]
-            else:
-                parsed[key] = constructor(obj.uuid, self.save)
-                self.parsed_objects[key] = parsed[key]
+            try:
+                if key in self.parsed_objects:
+                    parsed[key] = self.parsed_objects[key]
+                else:
+                    parsed[key] = constructor(obj.uuid, self.save)
+                    self.parsed_objects[key] = parsed[key]
+            except Exception as e:
+                if ArkSaveLogger._allow_invalid_objects:
+                    ArkSaveLogger.error_log(f"Failed to parse object {obj.uuid}: {e}")
+                else:
+                    raise e
 
         return parsed
     

{arkparse-0.2.2 → arkparse-0.2.4}/src/arkparse/api/json_api.py

@@ -279,6 +279,81 @@ class JsonApi:
 
         ArkSaveLogger.api_log("Player pawns successfully exported.")
 
+    def export_players(self, player_api: PlayerApi = None, export_folder_path: str = Path.cwd() / "json_exports"):
+        ArkSaveLogger.api_log("Exporting players...")
+
+        # Get player API if not provided.
+        if player_api is None:
+            player_api = PlayerApi(self.save, self.ignore_error)
+
+        # Format players into JSON.
+        all_players = []
+        for player in player_api.players:
+            player_json_obj = player.to_json_obj()
+            found: bool = False
+            for p in player_api.pawns.values():
+                uniqueid = p.get_property_value("PlatformProfileID", None)
+                if uniqueid is not None and hasattr(uniqueid, "value") and player.unique_id == uniqueid.value:
+                    found = True
+                    break
+            player_json_obj["FoundOnMap"] = found
+            all_players.append(player_json_obj)
+
+        # Create json exports folder if it does not exist.
+        path_obj = Path(export_folder_path)
+        if not (path_obj.exists() and path_obj.is_dir()):
+            path_obj.mkdir(parents=True, exist_ok=True)
+
+        # Write JSON.
+        with open(path_obj / "players.json", "w") as text_file:
+            text_file.write(json.dumps(all_players, default=lambda o: o.to_json_obj() if hasattr(o, 'to_json_obj') else None, indent=4, cls=DefaultJsonEncoder))
+
+        ArkSaveLogger.api_log("Players successfully exported.")
+
+    def export_tribes(self, player_api: PlayerApi = None, export_folder_path: str = Path.cwd() / "json_exports", include_players_data: bool = False):
+        ArkSaveLogger.api_log("Exporting tribes...")
+
+        # Get player API if not provided.
+        if player_api is None:
+            player_api = PlayerApi(self.save, self.ignore_error)
+
+        # Format tribes into JSON.
+        all_tribes = []
+        for tribe in player_api.tribes:
+            # Grab the tribe json object
+            tribe_json_obj = tribe.to_json_obj()
+            # Grab tribe members as json objects if they exists
+            tribe_members = []
+            for p in player_api.tribe_to_player_map[tribe.tribe_id]:
+                if include_players_data:
+                    player_json_obj = p.to_json_obj()
+                else:
+                    player_json_obj = { "PlayerCharacterName": p.char_name, "PlayerDataID": p.id_ }
+                player_json_obj["IsActive"] = True
+                tribe_members.append(player_json_obj)
+            for idx, p_id in enumerate(tribe.member_ids):
+                is_active = False
+                for pl in player_api.tribe_to_player_map[tribe.tribe_id]:
+                    if pl.id_ == p_id:
+                        is_active = True
+                if not is_active:
+                    tribe_members.append({ "PlayerCharacterName": tribe.members[idx], "PlayerDataID": p_id, "IsActive": False })
+            tribe_json_obj["TribeMembers"] = tribe_members
+            # Add to the tribes array
+            all_tribes.append(tribe_json_obj)
+
+        # Create json exports folder if it does not exist.
+        path_obj = Path(export_folder_path)
+        if not (path_obj.exists() and path_obj.is_dir()):
+            path_obj.mkdir(parents=True, exist_ok=True)
+
+        # Write JSON.
+        with open(path_obj / "tribes.json", "w") as text_file:
+            text_file.write(
+                json.dumps(all_tribes, default=lambda o: o.to_json_obj() if hasattr(o, 'to_json_obj') else None, indent=4, cls=DefaultJsonEncoder))
+
+        ArkSaveLogger.api_log("Tribes successfully exported.")
+
     def export_dinos(self, dino_api: DinoApi = None, export_folder_path: str = Path.cwd() / "json_exports"):
         ArkSaveLogger.api_log("Exporting dinos...")
 
@@ -313,11 +388,11 @@ class JsonApi:
             structure_api = StructureApi(self.save)
 
         # Get structures.
-        structures: list[Structure | StructureWithInventory] = structure_api.get_all_fast()
+        structures: dict[UUID, Structure | StructureWithInventory] = structure_api.get_all()
 
         # Format dinos into JSON.
         all_structures = []
-        for structure in structures:
+        for structure in structures.values():
             all_structures.append(structure.to_json_obj())
 
         # Create json exports folder if it does not exist.
@@ -340,27 +415,33 @@ class JsonApi:
         with self.save.connection as conn:
             cursor = conn.execute(query)
             for row in cursor:
-                obj_uuid = self.save.byte_array_to_uuid(row[0])
-                byte_buffer = ArkBinaryParser(row[1], self.save.save_context)
-                class_name = byte_buffer.read_name()
-
-                if "/PrimalItemArmor_" not in class_name and \
-                        "/PrimalItem_" not in class_name and \
-                        "/PrimalItemAmmo_" not in class_name and \
-                        "/PrimalItemC4Ammo" not in class_name and \
-                        "/PrimalItemResource_" not in class_name and \
-                        "/DroppedItemGeneric_" not in class_name and \
-                        "/PrimalItemConsumable_" not in class_name:
-                    continue
-
-                obj = self.save.parse_as_predefined_object(obj_uuid, class_name, byte_buffer)
-                if obj is not None:
-                    is_engram = False
-                    if obj.has_property("bIsEngram"):
-                        is_engram = obj.get_property_value("bIsEngram", False)
-                    if is_engram and not include_engrams:
+                try:
+                    obj_uuid = self.save.byte_array_to_uuid(row[0])
+                    byte_buffer = ArkBinaryParser(row[1], self.save.save_context)
+                    class_name = byte_buffer.read_name()
+
+                    if "/PrimalItemArmor_" not in class_name and \
+                            "/PrimalItem_" not in class_name and \
+                            "/PrimalItemAmmo_" not in class_name and \
+                            "/PrimalItemC4Ammo" not in class_name and \
+                            "/PrimalItemResource_" not in class_name and \
+                            "/DroppedItemGeneric_" not in class_name and \
+                            "/PrimalItemConsumable_" not in class_name:
                         continue
-                    all_items.append(JsonApi.primal_item_to_json_obj(obj))
+
+                    obj = self.save.parse_as_predefined_object(obj_uuid, class_name, byte_buffer)
+                    if obj is not None:
+                        is_engram = False
+                        if obj.has_property("bIsEngram"):
+                            is_engram = obj.get_property_value("bIsEngram", False)
+                        if is_engram and not include_engrams:
+                            continue
+                        all_items.append(JsonApi.primal_item_to_json_obj(obj))
+                except Exception as e:
+                    if ArkSaveLogger._allow_invalid_objects:
+                        ArkSaveLogger.error_log(f"Failed to parse item {UUID(row[0])}: {e}")
+                    else:
+                        raise e
 
         # Create json exports folder if it does not exist.
         path_obj = Path(export_folder_path)
@@ -373,12 +454,29 @@ class JsonApi:
 
         ArkSaveLogger.api_log("Items successfully exported.")
 
+    def export_save_file_info(self, export_folder_path: str = Path.cwd() / "json_exports"):
+        ArkSaveLogger.api_log("Exporting save file info...")
+
+        save_info = { "MapName": self.save.save_context.map_name, "GameTime": self.save.save_context.game_time }
+
+        # Create json exports folder if it does not exist.
+        path_obj = Path(export_folder_path)
+        if not (path_obj.exists() and path_obj.is_dir()):
+            path_obj.mkdir(parents=True, exist_ok=True)
+
+        # Write JSON.
+        with open(path_obj / "save_info.json", "w") as text_file:
+            text_file.write(json.dumps(save_info, default=lambda o: o.to_json_obj() if hasattr(o, 'to_json_obj') else None, indent=4, cls=DefaultJsonEncoder))
+
+        ArkSaveLogger.api_log("Save file info successfully exported.")
+
     def export_all(self,
                    equipment_api: EquipmentApi = None,
                    player_api: PlayerApi = None,
                    dino_api: DinoApi = None,
                    structure_api: StructureApi = None,
                    export_folder_path: str = Path.cwd() / "json_exports"):
+        self.export_save_file_info(export_folder_path=export_folder_path)
         self.export_armors(equipment_api=equipment_api, export_folder_path=export_folder_path)
         self.export_weapons(equipment_api=equipment_api, export_folder_path=export_folder_path)
         self.export_shields(equipment_api=equipment_api, export_folder_path=export_folder_path)
@@ -387,3 +485,5 @@ class JsonApi:
         self.export_structures(structure_api=structure_api, export_folder_path=export_folder_path)
         self.export_dinos(dino_api=dino_api, export_folder_path=export_folder_path)
         self.export_player_pawns(player_api=player_api, export_folder_path=export_folder_path)
+        self.export_players(player_api=player_api, export_folder_path=export_folder_path)
+        self.export_tribes(player_api=player_api, export_folder_path=export_folder_path)

{arkparse-0.2.2 → arkparse-0.2.4}/src/arkparse/api/player_api.py

@@ -125,7 +125,7 @@ class PlayerApi:
         OBJECT = 0
         DINO = 1
 
-    def __init__(self, save: AsaSave, ignore_error: bool = False):
+    def __init__(self, save: AsaSave, ignore_error: bool = False, no_pawns: bool = False):
         self.players: List[ArkPlayer] = []
         self.tribes: List[ArkTribe] = []
         self.tribe_to_player_map: Dict[int, List[ArkPlayer]] = {}
@@ -141,7 +141,7 @@ class PlayerApi:
             ArkSaveLogger.api_log("Profile data not found in save, checking database")
             self.from_store = False
 
-        if self.save is not None:
+        if self.save is not None and not no_pawns:
             ArkSaveLogger.api_log(f"Retrieving player pawns")
             self.__init_pawns()
 
@@ -326,6 +326,12 @@ class PlayerApi:
                 dict[p.id_] = p.stats.experience
 
         return self.__calc_stat(xp, stat_type) if not as_dict else dict
+
+    def get_tribe(self, tribe_id: int):
+        for t in self.tribes:
+            if t.tribe_id == tribe_id:
+                return t
+        return None
     
     def get_player_with(self, stat: int, stat_type: int = StatType.HIGHEST):
         istat = self.__get_stat(stat)