arkparser 0.6.0__tar.gz → 0.7.1__tar.gz

{arkparser-0.6.0 → arkparser-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arkparser
-Version: 0.6.0
+Version: 0.7.1
 Summary: Pure Python parser for ARK: Survival Evolved and ARK: Survival Ascended save files
 Author: Vertyco
 License-Expression: MIT
@@ -314,7 +314,7 @@ ARK keeps player data in **two distinct places**, and the parser builds `ASV_Pla
 
 The export pipeline (`export_players`) loops over `save.profiles` (a list the caller assembles). For each entry:
 
-- If it's a `Profile` instance → `_player_from_profile` runs: fills core identity (name, gender, level, stats, tribe id, engram count, experience, active datetime from `LastLoginTime`). Leaves `lat`/`lon`/`ccc` as zero, `inventory` empty, pawn-state flags (`is_sleeping`, `is_dead`, `chibi_levels`, …) absent.
+- If it's a `Profile` instance → `_player_from_profile` runs: fills core identity (name, gender, level, stats, tribe id, engram count, experience, active datetime from `LastLoginTime`). It joins `PlayerDataID == LinkedPlayerDataID` against the world save's player pawns, so when a live pawn exists `lat`/`lon`/`ccc` come from that pawn's `.location`; players with no live pawn (dead / logged out) keep `lat`/`lon`/`ccc` at zero. `inventory` is empty and pawn-state flags (`is_sleeping`, `is_dead`, `chibi_levels`, …) absent (the profile carries neither).
 - Otherwise it's treated as a wrapped `(profile, objects)` pair pointing at an in-world `PlayerPawn` → `_player_from_object` runs: fills location, inventory, pawn-state flags, body/hair cosmetics, death timestamps, and `active` from `SavedLastTimeHadController`.
 
 For the richest output, hand `export_players` **both**, assemble a wrapper for each player that carries the `Profile` (for offline identity) *and* the in-world pawn (when present) so the merged record gets identity + live state. The current validation script only passes `Profile` instances, which is why fields like `is_sleeping` / `body_colors` / `current_weapon` show up empty in the validation output even though the parser supports them.
@@ -336,7 +336,7 @@ For the richest output, hand `export_players` **both**, assemble a wrapper for e
 | `netAddress` | legacy (now populated) | Last client IP ARK persisted (`SavedNetworkAddress` in profile `MyData`). Legacy ASVExport reads the same field (ContentPlayer.cs:157 ASE / :341 ASA). `""` when the profile lacks it (e.g. never-played placeholders). ASA stores a clean IPv4/IPv6 string; some ASE saves store an engine-truncated value (e.g. `"[2001"`) reproduced verbatim, matching legacy. |
 | `steamid`, `dataFile` | legacy | platform net id and `{steamid}.arkprofile` filename |
 | `active` | legacy (now populated) | ISO 8601 datetime of last login, converted from profile `LastLoginTime` or in-world pawn `SavedLastTimeHadController`. Legacy schema reserved the field but the old C# exporter only filled it for in-world pawns; the parser fills it for profiles too. `null` when neither source is present. |
-| `lat`, `lon`, `ccc` | legacy (now populated) | In-world position when the record was built from a `PlayerPawn` GameObject. Records sourced from profile / cluster files keep the legacy `0` / `"0 0 0"` placeholders since profiles carry no world position. |
+| `lat`, `lon`, `ccc` | legacy (now populated) | In-world position. Built directly from a `PlayerPawn` GameObject when one is passed, and for profile-sourced records the parser joins `PlayerDataID == LinkedPlayerDataID` to the world save's player pawns and pulls the matched pawn's `.location`. Records whose player has no live pawn (dead / logged out / cluster-only) keep the legacy `0` / `"0 0 0"` placeholders since there is no world position to report. |
 | `inventory` | legacy (now populated) | Items from the pawn's `MyInventoryComponent` when built from an in-world pawn. Empty list otherwise. |
 | `engram_points` | added | `TotalEngramPoints` |
 | `experience` | added | `ExperiencePoints` (status), integer |
@@ -365,7 +365,7 @@ For the richest output, hand `export_players` **both**, assemble a wrapper for e
 | `members` | legacy | list of `{ign, lvl, playerid, playername, steamid}` built from the allocated players. `lvl` and `steamid` populate from the matching `.arkprofile`; members with no profile (back-filled from the tribe's member list) carry `lvl=0`, `steamid=""`. |
 | `tames`, `structures` | legacy | counts derived from `WorldSave` (creatures + structures whose `TargetingTeam` matches) |
 | `uploadedTames` | legacy | reserved (currently `0`) |
-| `active` | legacy | ISO 8601 datetime of the most recent tribe log entry, converted from in-game "Day N, HH:MM:SS" via the save's anchor. `null` when no parseable log entries or anchors are missing. |
+| `active` | legacy | ISO 8601 datetime, legacy `ContentTribe.LastActive`: max of the tribe file's write time (`.arktribe` mtime; world-save mtime for in-save tribes) and the allocated members' last-active times (`LastLoginTime` via the save anchor), discarding future values. `null` when no past candidate exists. Tribe-log "Day N" stamps are game-calendar time and are deliberately not used. |
 | `dataFile` | legacy | `"{tribeid}.arktribe"` filename pattern. |
 | `owner_id` | added | `OwnerPlayerDataID` / parser `Tribe.owner_player_id` |
 | `owner_name` | added | `OwnerPlayerName` (object form only; parser-tribe form has no equivalent) |
@@ -681,6 +681,15 @@ Schema policy:
 
 ASA worldsave property layouts differ between **v13** (`TheIsland_WP` and older single-player saves, legacy `AsaSavegameToolkit`-style `dataSize + position + typeRef + byte` body) and **v14+** (current production ASA, marker-based body). Both are parsed by version-aware property readers; `WorldSave.version` is the source of truth.
 
+### Parse diagnostics (logging)
+
+The parser logs through the standard `logging` module on the `arkparser.*` logger hierarchy. At DEBUG level it reports recoverable parse anomalies, for example ASE objects whose property block terminates early (the run of successfully parsed properties is kept and the remaining bytes are preserved on `GameObject.extra_data`):
+
+```python
+import logging
+logging.getLogger("arkparser").setLevel(logging.DEBUG)
+```
+
 ### Known limitation: ASA cryopod property blocks are partially decoded
 
 ASA cryopods (`PrimalItem_WeaponEmptyCryopod_C`, `SoulTrap`, `Vivarium`, `DinoBall`) store the embedded creature snapshot inside the item's `CustomItemDatas.CustomDataBytes.ByteArrays[0]` as a **zlib + custom-RLE compressed `AsaDataStore` blob**. The parser surfaces the snapshot via the simpler `CustomDataStrings` / `CustomDataFloats` accessors, exposing **species, tamed name, level, color regions, and `CurrentStatusValues[0..11]`** on each cryopodded creature.

{arkparser-0.6.0 → arkparser-0.7.1}/README.md

@@ -280,7 +280,7 @@ ARK keeps player data in **two distinct places**, and the parser builds `ASV_Pla
 
 The export pipeline (`export_players`) loops over `save.profiles` (a list the caller assembles). For each entry:
 
-- If it's a `Profile` instance → `_player_from_profile` runs: fills core identity (name, gender, level, stats, tribe id, engram count, experience, active datetime from `LastLoginTime`). Leaves `lat`/`lon`/`ccc` as zero, `inventory` empty, pawn-state flags (`is_sleeping`, `is_dead`, `chibi_levels`, …) absent.
+- If it's a `Profile` instance → `_player_from_profile` runs: fills core identity (name, gender, level, stats, tribe id, engram count, experience, active datetime from `LastLoginTime`). It joins `PlayerDataID == LinkedPlayerDataID` against the world save's player pawns, so when a live pawn exists `lat`/`lon`/`ccc` come from that pawn's `.location`; players with no live pawn (dead / logged out) keep `lat`/`lon`/`ccc` at zero. `inventory` is empty and pawn-state flags (`is_sleeping`, `is_dead`, `chibi_levels`, …) absent (the profile carries neither).
 - Otherwise it's treated as a wrapped `(profile, objects)` pair pointing at an in-world `PlayerPawn` → `_player_from_object` runs: fills location, inventory, pawn-state flags, body/hair cosmetics, death timestamps, and `active` from `SavedLastTimeHadController`.
 
 For the richest output, hand `export_players` **both**, assemble a wrapper for each player that carries the `Profile` (for offline identity) *and* the in-world pawn (when present) so the merged record gets identity + live state. The current validation script only passes `Profile` instances, which is why fields like `is_sleeping` / `body_colors` / `current_weapon` show up empty in the validation output even though the parser supports them.
@@ -302,7 +302,7 @@ For the richest output, hand `export_players` **both**, assemble a wrapper for e
 | `netAddress` | legacy (now populated) | Last client IP ARK persisted (`SavedNetworkAddress` in profile `MyData`). Legacy ASVExport reads the same field (ContentPlayer.cs:157 ASE / :341 ASA). `""` when the profile lacks it (e.g. never-played placeholders). ASA stores a clean IPv4/IPv6 string; some ASE saves store an engine-truncated value (e.g. `"[2001"`) reproduced verbatim, matching legacy. |
 | `steamid`, `dataFile` | legacy | platform net id and `{steamid}.arkprofile` filename |
 | `active` | legacy (now populated) | ISO 8601 datetime of last login, converted from profile `LastLoginTime` or in-world pawn `SavedLastTimeHadController`. Legacy schema reserved the field but the old C# exporter only filled it for in-world pawns; the parser fills it for profiles too. `null` when neither source is present. |
-| `lat`, `lon`, `ccc` | legacy (now populated) | In-world position when the record was built from a `PlayerPawn` GameObject. Records sourced from profile / cluster files keep the legacy `0` / `"0 0 0"` placeholders since profiles carry no world position. |
+| `lat`, `lon`, `ccc` | legacy (now populated) | In-world position. Built directly from a `PlayerPawn` GameObject when one is passed, and for profile-sourced records the parser joins `PlayerDataID == LinkedPlayerDataID` to the world save's player pawns and pulls the matched pawn's `.location`. Records whose player has no live pawn (dead / logged out / cluster-only) keep the legacy `0` / `"0 0 0"` placeholders since there is no world position to report. |
 | `inventory` | legacy (now populated) | Items from the pawn's `MyInventoryComponent` when built from an in-world pawn. Empty list otherwise. |
 | `engram_points` | added | `TotalEngramPoints` |
 | `experience` | added | `ExperiencePoints` (status), integer |
@@ -331,7 +331,7 @@ For the richest output, hand `export_players` **both**, assemble a wrapper for e
 | `members` | legacy | list of `{ign, lvl, playerid, playername, steamid}` built from the allocated players. `lvl` and `steamid` populate from the matching `.arkprofile`; members with no profile (back-filled from the tribe's member list) carry `lvl=0`, `steamid=""`. |
 | `tames`, `structures` | legacy | counts derived from `WorldSave` (creatures + structures whose `TargetingTeam` matches) |
 | `uploadedTames` | legacy | reserved (currently `0`) |
-| `active` | legacy | ISO 8601 datetime of the most recent tribe log entry, converted from in-game "Day N, HH:MM:SS" via the save's anchor. `null` when no parseable log entries or anchors are missing. |
+| `active` | legacy | ISO 8601 datetime, legacy `ContentTribe.LastActive`: max of the tribe file's write time (`.arktribe` mtime; world-save mtime for in-save tribes) and the allocated members' last-active times (`LastLoginTime` via the save anchor), discarding future values. `null` when no past candidate exists. Tribe-log "Day N" stamps are game-calendar time and are deliberately not used. |
 | `dataFile` | legacy | `"{tribeid}.arktribe"` filename pattern. |
 | `owner_id` | added | `OwnerPlayerDataID` / parser `Tribe.owner_player_id` |
 | `owner_name` | added | `OwnerPlayerName` (object form only; parser-tribe form has no equivalent) |
@@ -647,6 +647,15 @@ Schema policy:
 
 ASA worldsave property layouts differ between **v13** (`TheIsland_WP` and older single-player saves, legacy `AsaSavegameToolkit`-style `dataSize + position + typeRef + byte` body) and **v14+** (current production ASA, marker-based body). Both are parsed by version-aware property readers; `WorldSave.version` is the source of truth.
 
+### Parse diagnostics (logging)
+
+The parser logs through the standard `logging` module on the `arkparser.*` logger hierarchy. At DEBUG level it reports recoverable parse anomalies, for example ASE objects whose property block terminates early (the run of successfully parsed properties is kept and the remaining bytes are preserved on `GameObject.extra_data`):
+
+```python
+import logging
+logging.getLogger("arkparser").setLevel(logging.DEBUG)
+```
+
 ### Known limitation: ASA cryopod property blocks are partially decoded
 
 ASA cryopods (`PrimalItem_WeaponEmptyCryopod_C`, `SoulTrap`, `Vivarium`, `DinoBall`) store the embedded creature snapshot inside the item's `CustomItemDatas.CustomDataBytes.ByteArrays[0]` as a **zlib + custom-RLE compressed `AsaDataStore` blob**. The parser surfaces the snapshot via the simpler `CustomDataStrings` / `CustomDataFloats` accessors, exposing **species, tamed name, level, color regions, and `CurrentStatusValues[0..11]`** on each cryopodded creature.

{arkparser-0.6.0 → arkparser-0.7.1}/arkparser/__init__.py

@@ -95,4 +95,4 @@ __all__ = [
     "ArkParseError",
 ]
 
-__version__ = "0.6.0"
+__version__ = "0.7.0"

{arkparser-0.6.0 → arkparser-0.7.1}/arkparser/common/types.py

@@ -21,6 +21,17 @@ from dataclasses import dataclass
 # The "None" name is used as a terminator in property lists
 NAME_NONE = "None"
 
+# Class-name / blueprint fragments that mark a creature-storage item.
+# Single source of truth for cryopod detection: in-world iteration
+# (WorldSave.iter_cryopod_creatures), inventory filtering (export), and
+# uploaded-item checks (UploadedItem.is_cryopod) all match against this.
+CRYOPOD_CLASS_PATTERNS: tuple[str, ...] = (
+    "Cryopod",
+    "SoulTrap",
+    "Vivarium",
+    "DinoBall",
+)
+
 
 # =============================================================================
 # ArkName (FName)

{arkparser-0.6.0 → arkparser-0.7.1}/arkparser/data_models.py

@@ -15,10 +15,14 @@ from dataclasses import dataclass, field
 
 from .common.binary_reader import BinaryReader
 from .common.normalization import normalize_indexed_data, normalize_indexed_list
+from .common.types import CRYOPOD_CLASS_PATTERNS
 from .properties.registry import read_properties
 
 logger = logging.getLogger(__name__)
 
+# Uploaded items match against lowercased blueprint paths.
+_CRYOPOD_PATTERNS_LOWER: tuple[str, ...] = tuple(p.lower() for p in CRYOPOD_CLASS_PATTERNS)
+
 # Trailing UE actor spawn-instance suffix on cryopod class names, e.g.
 # "Raptor_Character_BP_C_2145673735". ARK stores the full instance name in the
 # cryopod CustomDataStrings/SoftClasses blob; the worldsave name-table path
@@ -820,7 +824,7 @@ class UploadedItem:
     def is_cryopod(self) -> bool:
         """Check if this item is a cryopod (or similar creature storage item)."""
         bp_lower = self.blueprint.lower()
-        return any(x in bp_lower for x in ["cryopod", "soultrap", "vivarium", "dinoball"])
+        return any(x in bp_lower for x in _CRYOPOD_PATTERNS_LOWER)
 
     @property
     def cryopod_creature(self) -> CryopodCreature | None:

{arkparser-0.6.0 → arkparser-0.7.1}/arkparser/export.py

@@ -44,21 +44,14 @@ from pathlib import Path
 from arkparser.common.exceptions import ArkParseError
 from arkparser.common.map_config import MapConfig
 from arkparser.common.normalization import normalize_indexed_data, normalize_indexed_list
+from arkparser.common.types import CRYOPOD_CLASS_PATTERNS
 from arkparser.data_models import CryopodCreature
 from arkparser.files import CloudInventory, Profile, Tribe
 
 logger = logging.getLogger(__name__)
 
-_CRYOPOD_CLASS_PATTERNS: tuple[str, ...] = (
-    "Cryopod",
-    "SoulTrap",
-    "Vivarium",
-    "DinoBall",
-)
-
-
 def _is_cryopod_class(class_name: str) -> bool:
-    return any(p in class_name for p in _CRYOPOD_CLASS_PATTERNS)
+    return any(p in class_name for p in CRYOPOD_CLASS_PATTERNS)
 
 
 def _decode_inventory_cryopod(item_obj: t.Any) -> CryopodCreature | None:
@@ -152,6 +145,10 @@ _LEGACY_STAT_ORDER: tuple[str, ...] = (
 )
 _EXTRA_STAT_ORDER: tuple[str, ...] = ("torp", "water", "temp", "fort")
 _FLAT_STAT_ORDER: tuple[str, ...] = _LEGACY_STAT_ORDER + _EXTRA_STAT_ORDER
+# The order tuples are hand-maintained views of _STAT_NAMES; catch drift at
+# import time before it silently misaligns exported stat JSON.
+assert len(_FLAT_STAT_ORDER) == len(_STAT_NAMES), "stat order tuples out of sync"
+assert set(_FLAT_STAT_ORDER) == set(_STAT_NAMES), "stat order tuples out of sync"
 
 
 def _prop(obj: t.Any, name: str, default: t.Any = None, index: int | None = None) -> t.Any:
@@ -2058,6 +2055,8 @@ def _player_from_profile(
     profile: Profile,
     save: t.Any = None,
     pawn_status_by_id: dict[int, t.Any] | None = None,
+    pawn_by_data_id: dict[int, t.Any] | None = None,
+    map_config: MapConfig | None = None,
 ) -> dict[str, t.Any]:
     stat_points = [_int(profile.get_stat(i)["added"]) for i in range(12)]
     gamertag = profile.player_name or ""
@@ -2069,8 +2068,18 @@ def _player_from_profile(
     # not in the profile. Resolve via PlayerDataID -> pawn -> status. Absent
     # when the player has no spawned body (never spawned / corpse cleared).
     status = None
-    if pawn_status_by_id and profile.player_id:
-        status = pawn_status_by_id.get(int(profile.player_id))
+    pawn = None
+    if profile.player_id:
+        pid = int(profile.player_id)
+        if pawn_status_by_id:
+            status = pawn_status_by_id.get(pid)
+        if pawn_by_data_id:
+            pawn = pawn_by_data_id.get(pid)
+
+    # The profile carries no world position. When the player has a live pawn in
+    # the save, pull lat/lon/ccc from it; otherwise keep the legacy 0/0 zeroes
+    # (dead / logged-out players have no location to report).
+    gps = _gps_payload(pawn, map_config, ndigits=2) if pawn is not None else {"ccc": "0 0 0", "lat": 0.0, "lon": 0.0}
 
     out: dict[str, t.Any] = {
         "playerid": profile.player_id or 0,
@@ -2080,11 +2089,11 @@ def _player_from_profile(
         "tribe": profile.tribe_name or "",
         "sex": "Female" if profile.is_female is True else "Male",
         "lvl": profile.level,
-        "lat": 0.0,
-        "lon": 0.0,
+        "lat": gps["lat"],
+        "lon": gps["lon"],
         **_flat_stats(stat_points),
         "active": active_dt.isoformat() if active_dt is not None else None,
-        "ccc": "0 0 0",
+        "ccc": gps["ccc"],
         "achievements": [],
         "inventory": [],
         "netAddress": _str(profile.last_net_address),
@@ -2168,16 +2177,25 @@ def _player_from_object(
     return _compact(data, LEGACY_PLAYER_KEYS)
 
 
-def _player_status_by_data_id(save: t.Any, lookup: dict[t.Any, t.Any]) -> dict[int, t.Any]:
-    """Index ``MyCharacterStatusComponent`` per player by ``LinkedPlayerDataID``.
+def _player_status_by_data_id(
+    save: t.Any,
+    lookup: dict[t.Any, t.Any],
+) -> tuple[dict[int, t.Any], dict[int, t.Any]]:
+    """Index per-player pawn + status component by ``LinkedPlayerDataID``.
 
     Walks every ``PlayerPawnTest_*_C`` / ``PlayerCharacter_*`` in the world
     save, reads its ``LinkedPlayerDataID``, follows ``MyCharacterStatusComponent``
-    via ``lookup``, and stores the resolved status object. Lets profile-based
-    player exports surface live HP/stamina/food/etc. without legacy ASVPack
-    having to do the same join.
+    via ``lookup``, and stores both the resolved status object and the pawn
+    itself. The status index lets profile-based player exports surface live
+    HP/stamina/food/etc.; the pawn index lets them surface live lat/lon/ccc
+    (the pawn carries ``.location``, the profile does not), without legacy
+    ASVPack having to do the same join.
+
+    Returns ``(status_by_id, pawn_by_id)``; a pawn appears in ``pawn_by_id``
+    even when its status component fails to resolve.
     """
-    out: dict[int, t.Any] = {}
+    status_out: dict[int, t.Any] = {}
+    pawn_out: dict[int, t.Any] = {}
     objects = getattr(save, "objects", None) or []
     for obj in objects:
         cn = str(getattr(obj, "class_name", "") or "")
@@ -2186,10 +2204,11 @@ def _player_status_by_data_id(save: t.Any, lookup: dict[t.Any, t.Any]) -> dict[i
         pid = _int(_prop(obj, "LinkedPlayerDataID"))
         if not pid:
             continue
+        pawn_out[pid] = obj
         status = _status_for(obj, lookup)
         if status is not None:
-            out[pid] = status
-    return out
+            status_out[pid] = status
+    return status_out, pawn_out
 
 
 def _cluster_items_by_xuid(
@@ -2226,6 +2245,7 @@ def _player_record_for(
     entry: t.Any,
     save: t.Any,
     pawn_status_by_id: dict[int, t.Any],
+    pawn_by_data_id: dict[int, t.Any],
     lookup: dict[t.Any, t.Any],
     map_config: MapConfig | None,
 ) -> tuple[dict[str, t.Any] | None, list[str]]:
@@ -2237,7 +2257,7 @@ def _player_record_for(
     """
     join_keys: list[str] = []
     if isinstance(entry, Profile):
-        record = _player_from_profile(entry, save, pawn_status_by_id)
+        record = _player_from_profile(entry, save, pawn_status_by_id, pawn_by_data_id, map_config)
         if entry.source_path is not None and entry.source_path.stem:
             join_keys.append(entry.source_path.stem)
         if entry.unique_id:
@@ -2312,7 +2332,7 @@ def _iter_players(
     """Yield ASV_Players records one at a time (streaming form of export_players)."""
     profiles = _collection(save, "profiles", Profile)
     lookup = _save_lookup(save)
-    pawn_status_by_id = _player_status_by_data_id(save, lookup)
+    pawn_status_by_id, pawn_by_data_id = _player_status_by_data_id(save, lookup)
     cluster_items = _cluster_items_by_xuid(cluster_inventories, save) if cluster_inventories else {}
     # Legacy emits each player's tribeid as the CONTAINING tribe's id (the one
     # whose member list / team claims them), not the profile's own field. The
@@ -2321,7 +2341,9 @@ def _iter_players(
     profile_tribeid = allocation["profile_tribeid"]
     tribe_names = allocation["names"]
     for entry in profiles:
-        record, join_keys = _player_record_for(entry, save, pawn_status_by_id, lookup, map_config)
+        record, join_keys = _player_record_for(
+            entry, save, pawn_status_by_id, pawn_by_data_id, lookup, map_config
+        )
         if record is None:
             continue
         if isinstance(entry, Profile):
@@ -2388,45 +2410,67 @@ def _tribe_members_from_parser(
     return out
 
 
-def _tribe_active_iso(logs: t.Iterable[str], save: t.Any) -> str | None:
-    """Derive ``active`` ISO datetime from the most recent tribe log entry.
-
-    Tribe files don't carry an "active" timestamp directly. Each log entry
-    is formatted ``Day N, HH:MM:SS: <message>`` (game-time). The most recent
-    entry yields the highest game-second count, which combined with the
-    save's anchor (``file_mtime + (max_log_seconds - game_time)``) gives a
-    real wall-clock timestamp.
+def _tribe_file_date(tribe: t.Any, save: t.Any) -> dt.datetime | None:
+    """Wall-clock write time of a tribe's backing file (legacy TribeFileDate).
 
-    Returns ``None`` when no parseable log entry is found or the save lacks
-    conversion anchors.
+    File-backed tribes use the .arktribe mtime (ContentContainer.cs:1812);
+    tribes parsed out of the world save fall back to the save's own mtime
+    (ContentContainer.cs:734, GameSaveTime).
     """
-    max_seconds = 0
-    for raw in logs:
-        if not isinstance(raw, str):
-            continue
-        m = _LOG_RE.match(raw.strip())
-        if not m:
-            continue
+    src = getattr(tribe, "source_path", None) if tribe is not None else None
+    if src is not None:
         try:
-            day = int(m.group(1))
-        except (TypeError, ValueError):
-            continue
-        parts = m.group(2).split(":")
-        if len(parts) < 2:
-            continue
-        try:
-            h = int(parts[0])
-            mi = int(parts[1])
-            s = int(parts[2]) if len(parts) > 2 else 0
-        except (TypeError, ValueError):
-            continue
-        sec = day * 86400 + h * 3600 + mi * 60 + s
-        if sec > max_seconds:
-            max_seconds = sec
-    if not max_seconds:
+            local_tz = dt.datetime.now().astimezone().tzinfo
+            return dt.datetime.fromtimestamp(src.stat().st_mtime, tz=local_tz)
+        except OSError:
+            logger.debug("stat failed for tribe file %s", src)
+    return getattr(save, "file_mtime", None) if save is not None else None
+
+
+def _tribe_active_iso(
+    file_date: t.Any,
+    member_ids: t.Iterable[int],
+    profile_active: dict[int, dt.datetime],
+) -> str | None:
+    """Legacy ContentTribe.LastActive (ContentTribe.cs:35-49): the max of the
+    tribe file date and the members' last-active datetimes, discarding values
+    in the future. Tribe-log "Day N" stamps are game-calendar time, not real
+    seconds, so they cannot be converted with the save anchor and are unused.
+
+    Returns ``None`` when no past candidate exists.
+    """
+    assert isinstance(profile_active, dict), "profile_active must be a dict"
+    candidates: list[dt.datetime] = []
+    if isinstance(file_date, dt.datetime):
+        candidates.append(file_date if file_date.tzinfo else file_date.astimezone())
+    for i, pid in enumerate(member_ids):
+        assert i < _MAX_TRIBE_MEMBERS, "tribe member list exceeded bound"
+        active = profile_active.get(_int(pid))
+        if active is not None:
+            candidates.append(active if active.tzinfo else active.astimezone())
+    now = dt.datetime.now(dt.timezone.utc)
+    past = [c for c in candidates if c <= now]
+    if not past:
         return None
-    real = _approx_real_datetime(max_seconds, save)
-    return real.isoformat() if real is not None else None
+    return max(past).isoformat()
+
+
+def _profile_actives(profiles: list[Profile], save: t.Any) -> dict[int, dt.datetime]:
+    """``player_id -> last-active datetime`` for tribe activity rollups.
+
+    Mirrors legacy ContentPlayer.LastActiveDateTime: the profile's
+    LastLoginTime converted through the save anchor.
+    """
+    assert isinstance(profiles, list), "profiles must be a list"
+    out: dict[int, dt.datetime] = {}
+    for prof in profiles:
+        pid = _int(prof.player_id)
+        if not pid:
+            continue
+        active = _approx_real_datetime(prof.last_login_time, save)
+        if active is not None:
+            out[pid] = active
+    return out
 
 
 def _build_profile_index(save: t.Any) -> dict[int, Profile]:
@@ -2455,7 +2499,7 @@ def _tribe_from_parser(
         "tames": c.get("tames", 0),
         "uploadedTames": 0,
         "structures": c.get("structures", 0),
-        "active": _tribe_active_iso(tribe.log_entries, save),
+        "active": _tribe_file_date(tribe, save),
         "dataFile": f"{tid}.arktribe" if tid else "",
         "owner_id": tribe.owner_player_id or 0,
         "alliance_ids": tribe.alliance_ids,
@@ -2472,8 +2516,7 @@ def _tribe_from_object(
     tribe_id = _int(_prop(obj, "TribeID")) or _int(_prop(obj, "TribeId"))
     owner_id = _int(_prop(obj, "OwnerPlayerDataID")) or _int(_prop(obj, "OwnerPlayerDataId"))
     members: list[dict[str, t.Any]] = []
-    i = 0
-    while True:
+    for i in range(_MAX_TRIBE_MEMBERS):
         pid = _prop(obj, "MembersPlayerDataID", index=i)
         if pid is None:
             break
@@ -2489,15 +2532,14 @@ def _tribe_from_object(
                 "steamid": (profile.unique_id or "") if profile is not None else "",
             }
         )
-        i += 1
+    assert len(members) < _MAX_TRIBE_MEMBERS, "tribe member list exceeded bound"
     alliances: list[int] = []
-    j = 0
-    while True:
+    for j in range(_MAX_TRIBE_MEMBERS):
         val = _prop(obj, "TribeAlliances", index=j)
         if val is None:
             break
         alliances.append(_int(val))
-        j += 1
+    assert len(alliances) < _MAX_TRIBE_MEMBERS, "tribe alliance list exceeded bound"
     c = counts.get(tribe_id, {})
     data: dict[str, t.Any] = {
         "tribeid": tribe_id,
@@ -2507,7 +2549,7 @@ def _tribe_from_object(
         "tames": c.get("tames", 0),
         "uploadedTames": 0,
         "structures": c.get("structures", 0),
-        "active": _tribe_active_iso(_tribe_object_logs(obj), save),
+        "active": _tribe_file_date(None, save),
         "dataFile": f"{tribe_id}.arktribe" if tribe_id else "",
         "owner_id": owner_id,
         "owner_name": _str(_prop(obj, "OwnerPlayerName")),
@@ -2522,14 +2564,15 @@ def _tribe_object_logs(obj: t.Any) -> list[str]:
     if isinstance(log_val, list):
         return [e for e in log_val if isinstance(e, str) and e.strip()]
     out: list[str] = []
-    k = 0
-    while True:
+    entries = 0
+    for k in range(_MAX_TRIBE_MEMBERS):
         v = _prop(obj, "TribeLog", index=k)
         if v is None:
             break
+        entries += 1
         if isinstance(v, str) and v.strip():
             out.append(v)
-        k += 1
+    assert entries < _MAX_TRIBE_MEMBERS, "tribe log list exceeded bound"
     return out
 
 
@@ -2725,6 +2768,7 @@ def _assemble_tribes(save: t.Any) -> dict[str, t.Any]:
                 member_name.setdefault(pid, mname)
     file_tribe_ids = set(rich) | {_UNCLAIMED_TRIBE_ID, _ABANDONED_TRIBE_ID}
     profiles = _profile_entries(save)
+    profile_active = _profile_actives(profiles, save)
     profile_tribeid, players_by_tribe = _allocate_profiles(profiles, file_tribe_ids, member_index)
     for prof in profiles:
         pid = _int(prof.player_id)
@@ -2750,6 +2794,7 @@ def _assemble_tribes(save: t.Any) -> dict[str, t.Any]:
         "logs": logs,
         "counts": counts,
         "profile_index": profile_index,
+        "profile_active": profile_active,
         "players_by_tribe": players_by_tribe,
         "profile_tribeid": profile_tribeid,
         "member_stubs": member_stubs,
@@ -2796,10 +2841,12 @@ def _members_for(tid: int, a: dict[str, t.Any]) -> list[dict[str, t.Any]]:
 def _tribe_record(tid: int, a: dict[str, t.Any]) -> dict[str, t.Any]:
     """Final ASV_Tribes record for one assembled tribe id.
 
-    File-backed tribes reuse the rich record (active/dataFile/owner/alliances)
-    but have ``players``/``members`` overridden to the allocated-player set so
+    File-backed tribes reuse the rich record (dataFile/owner/alliances) but
+    have ``players``/``members`` overridden to the allocated-player set so
     they match the legacy writer (which counts allocated profiles, not the raw
     member list). Synthesized stubs carry id + name + world-derived counts.
+    ``active`` finalizes here for both shapes: max of the tribe file date and
+    the allocated members' last-active times (legacy ContentTribe.LastActive).
     """
     players = a["players_by_tribe"].get(tid, [])
     base = a["rich"].get(tid)
@@ -2807,6 +2854,7 @@ def _tribe_record(tid: int, a: dict[str, t.Any]) -> dict[str, t.Any]:
         rec = dict(base)
         rec["players"] = len(players)
         rec["members"] = _members_for(tid, a)
+        rec["active"] = _tribe_active_iso(rec.get("active"), players, a["profile_active"])
         return rec
     c = a["counts"].get(tid, {})
     data: dict[str, t.Any] = {
@@ -2817,7 +2865,7 @@ def _tribe_record(tid: int, a: dict[str, t.Any]) -> dict[str, t.Any]:
         "tames": c.get("tames", 0),
         "uploadedTames": 0,
         "structures": c.get("structures", 0),
-        "active": None,
+        "active": _tribe_active_iso(None, players, a["profile_active"]),
         "dataFile": "",
     }
     return _compact(data, LEGACY_TRIBE_KEYS)

{arkparser-0.6.0 → arkparser-0.7.1}/arkparser/files/world_save.py

@@ -34,6 +34,7 @@ from uuid import UUID
 from ..common.binary_reader import BinaryReader, guid_str_le
 from ..common.exceptions import ArkParseError, CorruptDataError
 from ..common.normalization import normalize_indexed_data, normalize_indexed_list
+from ..common.types import CRYOPOD_CLASS_PATTERNS
 from ..data_models import CryopodCreature
 from ..game_objects.container import GameObjectContainer
 from ..game_objects.game_object import MAX_OBJECT_COUNT, GameObject
@@ -428,13 +429,10 @@ class WorldSave:
         """Return creature nest objects (wyvern, drake, etc.)."""
         return self.container.get_nests()
 
-    # Class-name fragments that indicate a creature-storage item. Mirrors
-    # data_models.UploadedItem.is_cryopod (which matches against blueprint
-    # paths); the in-world version matches against the GameObject's
-    # ``class_name`` directly.
-    _CRYOPOD_PATTERNS: t.ClassVar[tuple[str, ...]] = (
-        "Cryopod", "SoulTrap", "Vivarium", "DinoBall",
-    )
+    # Shared with data_models.UploadedItem.is_cryopod (blueprint paths) and
+    # the export inventory filter; the in-world version matches against the
+    # GameObject's ``class_name`` directly.
+    _CRYOPOD_PATTERNS: t.ClassVar[tuple[str, ...]] = CRYOPOD_CLASS_PATTERNS
 
     def iter_cryopod_creatures(self) -> t.Iterator[tuple[GameObject, CryopodCreature]]:
         """Yield ``(item_obj, CryopodCreature)`` for every *filled* cryopod

{arkparser-0.6.0 → arkparser-0.7.1}/arkparser/game_objects/game_object.py

@@ -7,6 +7,7 @@ Game objects represent creatures, items, structures, players, and other entities
 
 from __future__ import annotations
 
+import logging
 import re
 import typing as t
 from collections import defaultdict
@@ -16,6 +17,8 @@ from ..common.exceptions import CorruptDataError
 from ..properties.registry import read_properties, read_property
 from .location import LocationData
 
+logger = logging.getLogger(__name__)
+
 if t.TYPE_CHECKING:
     from ..common.binary_reader import BinaryReader
     from ..properties.base import Property
@@ -420,11 +423,18 @@ class GameObject:
                     if prop is None:
                         break
                     properties.append(prop)
-            except Exception:
+            except Exception as exc:
                 self.properties = properties
                 self._props_loaded = True
                 if next_object is None:
                     raise
+                logger.debug(
+                    "property parse stopped early for %s after %d properties, "
+                    "remainder kept as extra_data: %s",
+                    self.class_name,
+                    len(properties),
+                    exc,
+                )
 
                 next_offset = properties_block_offset + next_object.properties_offset
                 remaining = next_offset - reader.position

{arkparser-0.6.0 → arkparser-0.7.1}/arkparser.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arkparser
-Version: 0.6.0
+Version: 0.7.1
 Summary: Pure Python parser for ARK: Survival Evolved and ARK: Survival Ascended save files
 Author: Vertyco
 License-Expression: MIT
@@ -314,7 +314,7 @@ ARK keeps player data in **two distinct places**, and the parser builds `ASV_Pla
 
 The export pipeline (`export_players`) loops over `save.profiles` (a list the caller assembles). For each entry:
 
-- If it's a `Profile` instance → `_player_from_profile` runs: fills core identity (name, gender, level, stats, tribe id, engram count, experience, active datetime from `LastLoginTime`). Leaves `lat`/`lon`/`ccc` as zero, `inventory` empty, pawn-state flags (`is_sleeping`, `is_dead`, `chibi_levels`, …) absent.
+- If it's a `Profile` instance → `_player_from_profile` runs: fills core identity (name, gender, level, stats, tribe id, engram count, experience, active datetime from `LastLoginTime`). It joins `PlayerDataID == LinkedPlayerDataID` against the world save's player pawns, so when a live pawn exists `lat`/`lon`/`ccc` come from that pawn's `.location`; players with no live pawn (dead / logged out) keep `lat`/`lon`/`ccc` at zero. `inventory` is empty and pawn-state flags (`is_sleeping`, `is_dead`, `chibi_levels`, …) absent (the profile carries neither).
 - Otherwise it's treated as a wrapped `(profile, objects)` pair pointing at an in-world `PlayerPawn` → `_player_from_object` runs: fills location, inventory, pawn-state flags, body/hair cosmetics, death timestamps, and `active` from `SavedLastTimeHadController`.
 
 For the richest output, hand `export_players` **both**, assemble a wrapper for each player that carries the `Profile` (for offline identity) *and* the in-world pawn (when present) so the merged record gets identity + live state. The current validation script only passes `Profile` instances, which is why fields like `is_sleeping` / `body_colors` / `current_weapon` show up empty in the validation output even though the parser supports them.
@@ -336,7 +336,7 @@ For the richest output, hand `export_players` **both**, assemble a wrapper for e
 | `netAddress` | legacy (now populated) | Last client IP ARK persisted (`SavedNetworkAddress` in profile `MyData`). Legacy ASVExport reads the same field (ContentPlayer.cs:157 ASE / :341 ASA). `""` when the profile lacks it (e.g. never-played placeholders). ASA stores a clean IPv4/IPv6 string; some ASE saves store an engine-truncated value (e.g. `"[2001"`) reproduced verbatim, matching legacy. |
 | `steamid`, `dataFile` | legacy | platform net id and `{steamid}.arkprofile` filename |
 | `active` | legacy (now populated) | ISO 8601 datetime of last login, converted from profile `LastLoginTime` or in-world pawn `SavedLastTimeHadController`. Legacy schema reserved the field but the old C# exporter only filled it for in-world pawns; the parser fills it for profiles too. `null` when neither source is present. |
-| `lat`, `lon`, `ccc` | legacy (now populated) | In-world position when the record was built from a `PlayerPawn` GameObject. Records sourced from profile / cluster files keep the legacy `0` / `"0 0 0"` placeholders since profiles carry no world position. |
+| `lat`, `lon`, `ccc` | legacy (now populated) | In-world position. Built directly from a `PlayerPawn` GameObject when one is passed, and for profile-sourced records the parser joins `PlayerDataID == LinkedPlayerDataID` to the world save's player pawns and pulls the matched pawn's `.location`. Records whose player has no live pawn (dead / logged out / cluster-only) keep the legacy `0` / `"0 0 0"` placeholders since there is no world position to report. |
 | `inventory` | legacy (now populated) | Items from the pawn's `MyInventoryComponent` when built from an in-world pawn. Empty list otherwise. |
 | `engram_points` | added | `TotalEngramPoints` |
 | `experience` | added | `ExperiencePoints` (status), integer |
@@ -365,7 +365,7 @@ For the richest output, hand `export_players` **both**, assemble a wrapper for e
 | `members` | legacy | list of `{ign, lvl, playerid, playername, steamid}` built from the allocated players. `lvl` and `steamid` populate from the matching `.arkprofile`; members with no profile (back-filled from the tribe's member list) carry `lvl=0`, `steamid=""`. |
 | `tames`, `structures` | legacy | counts derived from `WorldSave` (creatures + structures whose `TargetingTeam` matches) |
 | `uploadedTames` | legacy | reserved (currently `0`) |
-| `active` | legacy | ISO 8601 datetime of the most recent tribe log entry, converted from in-game "Day N, HH:MM:SS" via the save's anchor. `null` when no parseable log entries or anchors are missing. |
+| `active` | legacy | ISO 8601 datetime, legacy `ContentTribe.LastActive`: max of the tribe file's write time (`.arktribe` mtime; world-save mtime for in-save tribes) and the allocated members' last-active times (`LastLoginTime` via the save anchor), discarding future values. `null` when no past candidate exists. Tribe-log "Day N" stamps are game-calendar time and are deliberately not used. |
 | `dataFile` | legacy | `"{tribeid}.arktribe"` filename pattern. |
 | `owner_id` | added | `OwnerPlayerDataID` / parser `Tribe.owner_player_id` |
 | `owner_name` | added | `OwnerPlayerName` (object form only; parser-tribe form has no equivalent) |
@@ -681,6 +681,15 @@ Schema policy:
 
 ASA worldsave property layouts differ between **v13** (`TheIsland_WP` and older single-player saves, legacy `AsaSavegameToolkit`-style `dataSize + position + typeRef + byte` body) and **v14+** (current production ASA, marker-based body). Both are parsed by version-aware property readers; `WorldSave.version` is the source of truth.
 
+### Parse diagnostics (logging)
+
+The parser logs through the standard `logging` module on the `arkparser.*` logger hierarchy. At DEBUG level it reports recoverable parse anomalies, for example ASE objects whose property block terminates early (the run of successfully parsed properties is kept and the remaining bytes are preserved on `GameObject.extra_data`):
+
+```python
+import logging
+logging.getLogger("arkparser").setLevel(logging.DEBUG)
+```
+
 ### Known limitation: ASA cryopod property blocks are partially decoded
 
 ASA cryopods (`PrimalItem_WeaponEmptyCryopod_C`, `SoulTrap`, `Vivarium`, `DinoBall`) store the embedded creature snapshot inside the item's `CustomItemDatas.CustomDataBytes.ByteArrays[0]` as a **zlib + custom-RLE compressed `AsaDataStore` blob**. The parser surfaces the snapshot via the simpler `CustomDataStrings` / `CustomDataFloats` accessors, exposing **species, tamed name, level, color regions, and `CurrentStatusValues[0..11]`** on each cryopodded creature.

{arkparser-0.6.0 → arkparser-0.7.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "arkparser"
-version = "0.6.0"
+version = "0.7.1"
 description = "Pure Python parser for ARK: Survival Evolved and ARK: Survival Ascended save files"
 readme = "README.md"
 license = "MIT"

arkparser-0.7.1/tests/test_export.py

@@ -0,0 +1,177 @@
+"""Regression tests for export helpers against real parser objects."""
+
+import datetime as dt
+import os
+import shutil
+from pathlib import Path
+
+import pytest
+
+from arkparser import Profile, Tribe, WorldSave
+from arkparser.export import (
+    export_all,
+    export_players,
+    export_structures,
+    export_tamed,
+    export_to_files,
+    export_tribe_logs,
+    export_tribes,
+    export_wild,
+)
+
+_EXAMPLES = Path(__file__).parent.parent / "references" / "examples"
+_ASE_SCORCHED_EARTH = _EXAMPLES / "ase" / "maps" / "scorchedearth" / "ScorchedEarth_P.ark"
+_MAP_DUMP_EXTINCTION = Path(__file__).parent.parent / "references" / "map_dumps" / "evolved" / "extinction"
+
+
+def _first_dump_file(pattern: str) -> Path:
+    """First map-dump fixture matching ``pattern``, else skip the test."""
+    if _MAP_DUMP_EXTINCTION.is_dir():
+        files = sorted(_MAP_DUMP_EXTINCTION.glob(pattern))
+        if files:
+            return files[0]
+    pytest.skip(f"no {pattern} fixture under {_MAP_DUMP_EXTINCTION}")
+
+
+def _profile_with_last_login() -> Profile:
+    """First map-dump profile carrying LastLoginTime, else skip the test."""
+    if _MAP_DUMP_EXTINCTION.is_dir():
+        for path in sorted(_MAP_DUMP_EXTINCTION.glob("*.arkprofile"))[:50]:
+            try:
+                profile = Profile.load(path)
+            except Exception:  # noqa: BLE001 - corrupt fixture must not abort
+                continue
+            if profile.last_login_time and profile.player_id:
+                return profile
+    pytest.skip(f"no profile with LastLoginTime under {_MAP_DUMP_EXTINCTION}")
+
+_ASV_NAMES = {
+    "ASV_Tamed",
+    "ASV_Wild",
+    "ASV_Players",
+    "ASV_Tribes",
+    "ASV_Structures",
+    "ASV_TribeLogs",
+    "ASV_MapStructures",
+}
+
+
+@pytest.fixture(scope="session")
+def ase_export_world_save() -> WorldSave:
+    if not _ASE_SCORCHED_EARTH.exists():
+        pytest.skip(f"Fixture not available: {_ASE_SCORCHED_EARTH}")
+    return WorldSave.load(_ASE_SCORCHED_EARTH)
+
+
+def test_export_tamed_matches_world_save(ase_export_world_save: WorldSave) -> None:
+    exported = export_tamed(ase_export_world_save)
+    assert len(exported) == len(ase_export_world_save.get_tamed_creatures())
+    assert any(creature.get("name") == "escobar" for creature in exported)
+
+
+def test_export_wild_matches_world_save(ase_export_world_save: WorldSave) -> None:
+    exported = export_wild(ase_export_world_save)
+    assert len(exported) == len(ase_export_world_save.get_wild_creatures())
+    assert all(creature.get("tamer", "") == "" for creature in exported[:100])
+
+
+def test_export_structures_matches_world_save(ase_export_world_save: WorldSave) -> None:
+    exported = export_structures(ase_export_world_save)
+    assert len(exported) == len(ase_export_world_save.get_structures())
+
+
+def test_export_players_uses_profile_parser(ase_profile_path: Path) -> None:
+    profile = Profile.load(ase_profile_path)
+    exported = export_players(type("Holder", (), {"profiles": [profile]})())
+    assert exported[0]["playerid"] == profile.player_id
+    assert exported[0]["steam"] == profile.player_name
+    assert exported[0]["name"] == profile.character_name
+    assert exported[0]["sex"] == ("Female" if profile.is_female else "Male")
+    assert exported[0]["tribeid"] == profile.tribe_id
+
+
+def test_export_tribes_uses_tribe_parser(ase_tribe_path: Path) -> None:
+    tribe = Tribe.load(ase_tribe_path)
+    exported = export_tribes(type("Holder", (), {"tribes": [tribe]})())
+    assert exported[0]["tribeid"] == tribe.tribe_id
+    assert exported[0]["tribe"] == tribe.name
+    assert exported[0]["players"] == tribe.member_count
+
+
+def test_export_tribes_active_is_file_mtime(tmp_path: Path) -> None:
+    """Tribe ``active`` mirrors legacy ContentTribe.LastActive: the .arktribe
+    file's write time, never a value derived from in-game log day numbers
+    (those use the game calendar, not real seconds, and produced far-future
+    dates)."""
+    tribe_path = _first_dump_file("*.arktribe")
+    copy = tmp_path / tribe_path.name
+    shutil.copy2(tribe_path, copy)
+    local_tz = dt.datetime.now().astimezone().tzinfo
+    stamp = dt.datetime(2024, 5, 1, 12, 0, 0, tzinfo=local_tz)
+    os.utime(copy, (stamp.timestamp(), stamp.timestamp()))
+    tribe = Tribe.load(copy)
+    now = dt.datetime.now(tz=local_tz)
+    holder = type("Holder", (), {"tribes": [tribe], "file_mtime": now, "game_time": 5_000.0})()
+    exported = export_tribes(holder)
+    rec = next(r for r in exported if r["tribeid"] == tribe.tribe_id)
+    assert rec["active"] is not None
+    active = dt.datetime.fromisoformat(rec["active"])
+    assert active.timestamp() == pytest.approx(stamp.timestamp(), abs=2)
+    assert active <= now
+
+
+def test_export_tribes_solo_active_from_profile_last_login() -> None:
+    """A profile-only (solo) tribe gets ``active`` from the member's
+    LastLoginTime converted through the save anchor, matching legacy
+    ContentTribe.LastActive over allocated players."""
+    profile = _profile_with_last_login()
+    local_tz = dt.datetime.now().astimezone().tzinfo
+    now = dt.datetime.now(tz=local_tz)
+    game_time = float(profile.last_login_time) + 3_600.0
+    holder = type(
+        "Holder",
+        (),
+        {"tribes": [], "profiles": [profile], "file_mtime": now, "game_time": game_time},
+    )()
+    exported = export_tribes(holder)
+    rec = next(r for r in exported if r["tribeid"] == profile.player_id)
+    assert rec["active"] is not None
+    active = dt.datetime.fromisoformat(rec["active"])
+    expected = now - dt.timedelta(seconds=3_600)
+    assert active.timestamp() == pytest.approx(expected.timestamp(), abs=2)
+
+
+def test_export_tribes_active_never_future() -> None:
+    """Future candidates are discarded (legacy filters d <= DateTime.Now)."""
+    profile = _profile_with_last_login()
+    local_tz = dt.datetime.now().astimezone().tzinfo
+    now = dt.datetime.now(tz=local_tz)
+    game_time = max(float(profile.last_login_time) - 100_000_000.0, 1.0)
+    holder = type(
+        "Holder",
+        (),
+        {"tribes": [], "profiles": [profile], "file_mtime": now, "game_time": game_time},
+    )()
+    exported = export_tribes(holder)
+    rec = next(r for r in exported if r["tribeid"] == profile.player_id)
+    assert rec["active"] is None
+
+
+def test_export_tribe_logs_uses_tribe_parser(ase_tribe_path: Path) -> None:
+    tribe = Tribe.load(ase_tribe_path)
+    exported = export_tribe_logs(type("Holder", (), {"tribes": [tribe]})())
+    assert exported[0]["tribeid"] == tribe.tribe_id
+    assert exported[0]["tribe"] == tribe.name
+    assert exported[0]["logs"] == tribe.log_entries
+
+
+def test_export_all_uses_asv_names(ase_export_world_save: WorldSave) -> None:
+    exported = export_all(ase_export_world_save)
+    assert set(exported) == _ASV_NAMES
+
+
+def test_export_to_files_uses_asv_names(
+    ase_export_world_save: WorldSave, tmp_path: Path
+) -> None:
+    created = export_to_files(ase_export_world_save, tmp_path)
+    assert {path.name for path in created} == {f"{name}.json" for name in _ASV_NAMES}

arkparser-0.6.0/tests/test_export.py

@@ -1,92 +0,0 @@
-"""Regression tests for export helpers against real parser objects."""
-
-from pathlib import Path
-
-import pytest
-
-from arkparser import Profile, Tribe, WorldSave
-from arkparser.export import (
-    export_all,
-    export_players,
-    export_structures,
-    export_tamed,
-    export_to_files,
-    export_tribe_logs,
-    export_tribes,
-    export_wild,
-)
-
-_EXAMPLES = Path(__file__).parent.parent / "references" / "examples"
-_ASE_SCORCHED_EARTH = _EXAMPLES / "ase" / "maps" / "scorchedearth" / "ScorchedEarth_P.ark"
-
-_ASV_NAMES = {
-    "ASV_Tamed",
-    "ASV_Wild",
-    "ASV_Players",
-    "ASV_Tribes",
-    "ASV_Structures",
-    "ASV_TribeLogs",
-    "ASV_MapStructures",
-}
-
-
-@pytest.fixture(scope="session")
-def ase_export_world_save() -> WorldSave:
-    if not _ASE_SCORCHED_EARTH.exists():
-        pytest.skip(f"Fixture not available: {_ASE_SCORCHED_EARTH}")
-    return WorldSave.load(_ASE_SCORCHED_EARTH)
-
-
-def test_export_tamed_matches_world_save(ase_export_world_save: WorldSave) -> None:
-    exported = export_tamed(ase_export_world_save)
-    assert len(exported) == len(ase_export_world_save.get_tamed_creatures())
-    assert any(creature.get("name") == "escobar" for creature in exported)
-
-
-def test_export_wild_matches_world_save(ase_export_world_save: WorldSave) -> None:
-    exported = export_wild(ase_export_world_save)
-    assert len(exported) == len(ase_export_world_save.get_wild_creatures())
-    assert all(creature.get("tamer", "") == "" for creature in exported[:100])
-
-
-def test_export_structures_matches_world_save(ase_export_world_save: WorldSave) -> None:
-    exported = export_structures(ase_export_world_save)
-    assert len(exported) == len(ase_export_world_save.get_structures())
-
-
-def test_export_players_uses_profile_parser(ase_profile_path: Path) -> None:
-    profile = Profile.load(ase_profile_path)
-    exported = export_players(type("Holder", (), {"profiles": [profile]})())
-    assert exported[0]["playerid"] == profile.player_id
-    assert exported[0]["steam"] == profile.player_name
-    assert exported[0]["name"] == profile.character_name
-    assert exported[0]["sex"] == ("Female" if profile.is_female else "Male")
-    assert exported[0]["tribeid"] == profile.tribe_id
-
-
-def test_export_tribes_uses_tribe_parser(ase_tribe_path: Path) -> None:
-    tribe = Tribe.load(ase_tribe_path)
-    exported = export_tribes(type("Holder", (), {"tribes": [tribe]})())
-    assert exported[0]["tribeid"] == tribe.tribe_id
-    assert exported[0]["tribe"] == tribe.name
-    assert exported[0]["players"] == tribe.member_count
-
-
-def test_export_tribe_logs_uses_tribe_parser(ase_tribe_path: Path) -> None:
-    tribe = Tribe.load(ase_tribe_path)
-    exported = export_tribe_logs(type("Holder", (), {"tribes": [tribe]})())
-    assert exported[0]["tribeid"] == tribe.tribe_id
-    assert exported[0]["tribe"] == tribe.name
-    assert exported[0]["logs"] == tribe.log_entries
-
-
-def test_export_all_uses_asv_names(ase_export_world_save: WorldSave) -> None:
-    exported = export_all(ase_export_world_save)
-    assert set(exported) == _ASV_NAMES
-
-
-def test_export_to_files_uses_asv_names(
-    ase_export_world_save: WorldSave, tmp_path: Path
-) -> None:
-    created = export_to_files(ase_export_world_save, tmp_path)
-    assert {path.name for path in created} == {f"{name}.json" for name in _ASV_NAMES}