Move timestamp conflicts caching to ModInfo: RRR TTT

Utumno · Utumno · commit 863e1453fbeb · 2025-11-02T00:15:09.000+02:00
This is to fix a bug reported by @ RRR sibir-ine: > When two plugins in a timestamp-based LO game have the same timestamp > & you attempt to resolve it by redating one of them via its Modified > field, it only updates the duplicate timestamp status of that plugin, > not both. This regressed in 8163746 The regression was due to passing the rdata instance to propagate_refresh (rather than True). Note that for a pure redate (that does not affect load_order) we need to manually add the info to redraw in ModDetails._extra_changes. That change in info status is only needed for the UI to detect the conflict, but moving it there raised several issues (like needing to pass caches into _set_icon_text). The solution adopted here was to build the cache alongside the other load order caches, ensuring correctness and simplifying the model. games_lo no longer builds its own _mtime_mods cache, which it never used and which added unnecessary complexity (cf the todo comment). Finally the conflict detection logic is now centralized in lo_cache rather than split across two modules. Took the opportunity to cleanup refresh a bit. Under # RRR 353, # RRR 578
diff --git a/Mopy/bash/bosh/__init__.py b/Mopy/bash/bosh/__init__.py
@@ -796,11 +796,11 @@ def txt_status(self, *, __st_names={ST_ACTIVE: _('Active'),
 
     def hasTimeConflict(self):
         """True if there is another mod with the same ftime."""
-        return load_order.has_load_order_conflict(self.fn_key)
+        return self.fn_key in self._store().lo_conflicts
 
     def hasActiveTimeConflict(self):
         """True if it has an active mtime conflict with another mod."""
-        return load_order.has_load_order_conflict_active(self.fn_key)
+        return self.fn_key in self._store().act_lo_conflicts
 
     def hasBadMasterNames(self): # used in status calculation
         """True if has a master with un unencodable name in cp1252."""
@@ -2131,10 +2131,32 @@ def _modinfos_cache_wrapper(self: ModInfos, *args, ldiff=None,
                         self[k].get_table_prop('allowGhosting', True)})
                 ldiff.affected.update(mod for mod, ghost_it in ghostify.items()
                                       if self[mod].setGhost(ghost_it))
+            # check for load order conflicts - if ldiff is empty we should keep
+            # it empty (for refresh to check if it needs the refreshes above),
+            # but we should notify the UI to redraw items that changed status
+            mt_conflicts_changes = set()
+            if bush.game.mtime_lo:
+                mtime_mods = defaultdict(set)
+                for mod, info in self.items():
+                    mtime_mods[int(info.ftime)].add(mod)
+                mtime_mods = {frozenset(v) for v in mtime_mods.values() if
+                              len(v) > 1} # keep conflicting sets of mods
+                if mtime_mods:
+                    lo_conflicts, act_lo_conflicts = set(), set()
+                    activ = {*load_order.cached_active_tuple()}
+                    for confls in mtime_mods:
+                        lo_conflicts |= confls
+                        if len(confls_act := confls & activ) > 1:
+                            act_lo_conflicts |= confls_act
+                    # mods that started/stopped conflicting
+                    mt_conflicts_changes |= (self.lo_conflicts ^ lo_conflicts |
+                        act_lo_conflicts ^ self.act_lo_conflicts)
+                    self.lo_conflicts = lo_conflicts
+                    self.act_lo_conflicts = act_lo_conflicts
             # note we ignore missing/added here - this is the responsibility of
             # refresh - if we are not called from refresh those should be empty
             return RefrData(ldiff.reordered | ldiff.affected |
-                            ldiff.act_ord_status())
+                            ldiff.act_ord_status() | mt_conflicts_changes)
         finally:
             self._lo_wip = list(load_order.cached_lo_tuple())
             self._active_wip = list(load_order.cached_active_tuple())
@@ -2219,6 +2241,8 @@ def __init__(self):
         global modInfos
         modInfos = self ##: hack needed in ModInfo.readHeader
         super().__init__(ModInfo)
+        # lo conflicts cache only used in _ModsUIList.set_item_format
+        self.lo_conflicts, self.act_lo_conflicts = set(), set()
 
     # Refresh - not quite surprisingly this is super complex - therefore define
     # refresh satellite methods before even defining the DataStore overrides
@@ -2237,26 +2261,25 @@ def refresh(self, refresh_in, *, booting=False, unlock_lo=False,
             bt_contents = set()  # No BashTags folder -> no BashTags files
         rdata = super().refresh(refresh_in, booting=booting,
                                 bt_contents=bt_contents)
-        mods_changes = bool(rdata)
         ldiff = LordDiff()
         if insert_after:
             lordata = self._lo_insert_after(insert_after, save_wip_lo=True,
                                             ldiff=ldiff)
         else: # if refresh_infos is False but mods are added force refresh
             lordata = self.refreshLoadOrder(ldiff=ldiff,
-                forceRefresh=mods_changes or unlock_lo,
+                forceRefresh=bool(rdata) or unlock_lo,
                 forceActive=bool(rdata.to_del), unlock_lo=unlock_lo)
             if not unlock_lo and ldiff.missing: # unlock_lo=True in delete/BAIN
                 self.warn_missing_lo_act.update(ldiff.missing)
-        rdata |= lordata
         # if load order did not change, we must perform the refreshes below
         if not ldiff:
             # in case ini files were deleted or modified or maybe string files
             # were deleted... we need a load order below: in skyrim we read
             # inis in active order - we then need to redraw what changed status
             rdata.redraw |= self._refresh_mod_inis_and_strings()
-            if mods_changes:
+            if rdata:
                 rdata.redraw |= self._file_or_active_updates()
+        rdata |= lordata
         self._voAvailable, self.voCurrent = bush.game.modding_esms(self)
         return rdata
 
diff --git a/Mopy/bash/games_lo.py b/Mopy/bash/games_lo.py
@@ -369,10 +369,6 @@ def set_load_order(self, lord, active, previous_lord=None,
                                      previous_lord)
         return lord, active # return what we set or was previously set
 
-    # Conflicts - only for timestamp games
-    def has_load_order_conflict(self, mod_name): return False
-    def has_load_order_conflict_active(self, mod_name, active): return False
-
     @classmethod
     def _must_update_active(cls, deleted_plugins, reord_plugins):
         raise NotImplementedError
@@ -714,25 +710,15 @@ def _must_update_active(cls, deleted_plugins, reord_plugins):
 class TimestampGame(LoGame):
     """Oblivion and other games where load order is set using modification
     times."""
-    # Intentionally imprecise mtime cache
-    _mtime_mods: defaultdict[int, set[Path]] = defaultdict(set)
 
     @staticmethod
     def _check_active_order(acti, lord):
         super(TimestampGame, TimestampGame)._check_active_order(acti, lord)
         return [] # no need to reorder plugins.txt - fix_lo.act_reordered False
 
     @classmethod
-    def _must_update_active(cls, deleted_plugins, reord_plugins): return deleted_plugins
-
-    def has_load_order_conflict(self, mod_name):
-        ti = int(self._mod_infos[mod_name].ftime)
-        return ti in self._mtime_mods and len(self._mtime_mods[ti]) > 1
-
-    def has_load_order_conflict_active(self, mod_name, active):
-        ti = int(self._mod_infos[mod_name].ftime)
-        return self.has_load_order_conflict(mod_name) and bool(
-            (self._mtime_mods[ti] - {mod_name}) & active)
+    def _must_update_active(cls, deleted_plugins, reord_plugins):
+        return deleted_plugins
 
     # Abstract overrides ------------------------------------------------------
     def __calculate_mtime_order(self, mods=None): # excludes mods in corrupted
@@ -742,7 +728,6 @@ def __calculate_mtime_order(self, mods=None): # excludes mods in corrupted
         return sorted(self._mod_infos if mods is None else mods, key=is_m)
 
     def _fetch_load_order(self, cached_load_order, cached_active):
-        self._rebuild_mtimes_cache() ##: will need that tweaked for lock load order
         return self.__calculate_mtime_order()
 
     def _persist_load_order(self, lord, active):
@@ -767,13 +752,6 @@ def _persist_load_order(self, lord, active):
             restamp.append((ordered, self._mod_infos[mod].ftime))
         for ordered, modification_time in restamp:
             self._mod_infos[ordered].setmtime(modification_time)
-        # rebuild our cache
-        self._rebuild_mtimes_cache()
-
-    def _rebuild_mtimes_cache(self):
-        self._mtime_mods.clear()
-        for mod, info in self._mod_infos.items():
-            self._mtime_mods[int(info.ftime)].add(mod)
 
     def _persist_if_changed(self, active, lord, previous_active,
                             previous_lord):
diff --git a/Mopy/bash/load_order.py b/Mopy/bash/load_order.py
@@ -427,15 +427,6 @@ def get_lo_files() -> set[bolt.Path]:
     # implementations
     return set(_lo_handler.get_lo_files())
 
-# Timestamp games helpers
-def has_load_order_conflict(mod_name):
-    return _lo_handler.has_load_order_conflict(mod_name)
-
-def has_load_order_conflict_active(mod_name):
-    if not cached_is_active(mod_name): return False
-    return _lo_handler.has_load_order_conflict_active(mod_name,
-                                                      _cached_lord.active)
-
 # Lock load order -------------------------------------------------------------
 def toggle_lock_load_order(user_warning_callback):
     global locked
