Sync gramps@maintenance/gramps61 with upstream/gramps-project (2026-07-04)

Author: github-actions[bot]

gramps/cli/user.py

@@ -70,6 +70,7 @@ def __init__(
         self.steps = 0
         self.current_step = 0
         self._input = input
+        self._print_func = lambda msg: self._fileout.write(msg + "\n")
 
         def yes(*args, **kwargs):
             return True

gramps/gen/filters/_genericfilter.py

@@ -277,10 +277,13 @@ def apply(
                 if id_list not given, all items in the database that
                 match the filter are returned as a list of handles
         """
-        start_time = time.time()
+        t0 = time.perf_counter()
         for rule in self.flist:
             rule.requestprepare(db, user)
-        LOG.debug("Prepare time: %s seconds", time.time() - start_time)
+        t1 = time.perf_counter()
+        LOG.debug("Prepare time: %s seconds", t1 - t0)
+        if user:
+            user.notify("Prepare time: %.3fs" % (t1 - t0))
 
         if self.logical_op == "and":
             apply_logical_op = self.and_test
@@ -291,8 +294,6 @@ def apply(
         else:
             raise Exception("invalid operator: %r" % self.logical_op)
 
-        start_time = time.time()
-
         # build the starting set of possible_handles to be filtered
         possible_handles: Set[PrimaryObjectHandle]
         if id_list is not None:
@@ -312,20 +313,22 @@ def apply(
         else:
             possible_handles = set(self.get_all_handles(db))
 
+        t2 = time.perf_counter()
         res = self.apply_logical_op_to_all(db, possible_handles, apply_logical_op, user)
+        t3 = time.perf_counter()
+        LOG.debug("Apply time: %s seconds", t3 - t2)
+        if user:
+            user.notify("Apply time: %.3fs" % (t3 - t2))
 
         # convert the filtered set of handles to the correct result type
         if id_list is not None and tupleind is not None:
-            # convert the final_list of handles back to the corresponding final_list of tuples
-            res = sorted(
-                [handle_tuple[handle] for handle in res],
-                key=lambda x: id_list.index(x),
-            )
+            # filter id_list to only matched handles, preserving original order
+            res_set = set(res)
+            res = [item for item in id_list if item[tupleind] in res_set]
         elif tree:
             # sort final_list into the same order as traversed by get_tree_cursor
-            res = sorted(res, key=lambda x: tree_handles.index(x))
-
-        LOG.debug("Apply time: %s seconds", time.time() - start_time)
+            tree_pos = {h: i for i, h in enumerate(tree_handles)}
+            res = sorted(res, key=lambda x: tree_pos[x])
 
         for rule in self.flist:
             rule.requestreset()

gramps/gen/user.py

@@ -39,6 +39,7 @@ def __init__(self, callback=None, error=None, uistate=None, dbstate=None):
         self._fileout = sys.stderr  # redirected to mocks by unit tests
         self.uistate = uistate
         self.dbstate = dbstate
+        self._print_func = lambda msg: None
 
     @abstractmethod
     def begin_progress(self, title, message, steps):
@@ -195,6 +196,20 @@ def info(self, msg1, infotext, parent=None, monospaced=False):
         Displays information to the user
         """
 
+    def notify(self, msg):
+        """Display an informational message via the current print function."""
+        self._print_func(msg)
+
+    @contextmanager
+    def notifying(self, func):
+        """Temporarily override the print function for this User instance."""
+        old = self._print_func
+        self._print_func = func
+        try:
+            yield
+        finally:
+            self._print_func = old
+
 
 class User(UserBase):
     """

gramps/gui/filters/sidebar/_sidebarfilter.py

@@ -161,11 +161,33 @@ def clicked(self, obj):
         if not self.filter_is_ok():
             return
         self.uistate.set_busy_cursor(True)
+        phase_msgs = []
         t1 = time.perf_counter()
-        self.clicked_func()
-        t2 = time.perf_counter()
-        msg = _("Elapsed time: %.2fs") % (t2 - t1)
-        self.msg_label.set_text(msg)
+
+        def render(searching=False):
+            lines = list(phase_msgs)
+            elapsed = time.perf_counter() - t1
+            lines.append(_("Elapsed time: %.2fs") % elapsed)
+            header = _("Searching...") + "\n" if searching else ""
+            self.msg_label.set_text(header + "\n".join(lines))
+
+        def live_print(msg):
+            phase_msgs.append(msg)
+            render(searching=True)
+            while Gtk.events_pending():
+                Gtk.main_iteration()
+
+        def live_step():
+            render(searching=True)
+
+        self.uistate.filter_print_func = live_print
+        self.uistate.filter_step_func = live_step
+        try:
+            self.clicked_func()
+        finally:
+            self.uistate.filter_print_func = None
+            self.uistate.filter_step_func = None
+        render(searching=False)
         self.msg_label.get_style_context().remove_class("error")
         self.uistate.set_busy_cursor(False)
 

gramps/gui/user.py

@@ -27,12 +27,15 @@
 #
 # -------------------------------------------------------------------------
 import sys
+import time
 
 # -------------------------------------------------------------------------
 #
 # Gramps modules
 #
 # -------------------------------------------------------------------------
+from gi.repository import Gtk
+
 from gramps.gen import user
 from .utils import ProgressMeter
 from .dialog import (
@@ -61,6 +64,9 @@ def __init__(
     ):  # TODO User API: gen==cli==gui
         user.UserBase.__init__(self, callback, error, uistate, dbstate)
         self._progress = None
+        self._last_pump = 0.0
+        self._pulse_progress = False
+        self._print_func = self._gui_print
 
         if parent:
             self.parent = parent
@@ -69,6 +75,26 @@ def __init__(
         else:
             self.parent = None
 
+    def begin_filter_progress(self):
+        """Start pulsing the status bar progress indicator during filter application."""
+        self._pulse_progress = True
+        if self.uistate is not None:
+            self.uistate.progress.show()
+
+    def end_filter_progress(self):
+        """Stop pulsing the status bar progress indicator after filter application."""
+        self._pulse_progress = False
+        if self.uistate is not None:
+            self.uistate.progress.hide()
+
+    def _gui_print(self, msg):
+        if self.uistate is not None:
+            hook = getattr(self.uistate, "filter_print_func", None)
+            if hook is not None:
+                hook(msg)
+                return
+        self._fileout.write(msg + "\n")
+
     def begin_progress(self, title, message, steps):
         """
         Start showing a progress indicator to the user.
@@ -95,6 +121,18 @@ def step_progress(self):
         """
         if self._progress:
             self._progress.step()
+        else:
+            now = time.monotonic()
+            if now - self._last_pump > 0.1:  # at most ~10 pumps/s
+                self._last_pump = now
+                if self._pulse_progress and self.uistate is not None:
+                    self.uistate.progress.pulse()
+                if self.uistate is not None:
+                    step_hook = getattr(self.uistate, "filter_step_func", None)
+                    if step_hook is not None:
+                        step_hook()
+                while Gtk.events_pending():
+                    Gtk.main_iteration()
 
     def end_progress(self):
         """

gramps/gui/views/treemodels/flatbasemodel.py

@@ -75,6 +75,8 @@
 from ...user import User
 from gramps.gen.proxy.cache import CacheProxyDb
 
+_ = glocale.translation.gettext
+
 # -------------------------------------------------------------------------
 #
 # FlatNodeMap
@@ -625,12 +627,21 @@ def _rebuild_filter(self, ignore=None):
                 allkeys = self.sort_keys()
             if self.search:
                 ident = False
-                if ignore is None:
-                    dlist = self.search.apply(cdb, allkeys, tupleind=1, user=self.user)
-                else:
-                    dlist = self.search.apply(
-                        cdb, [k for k in allkeys if k[1] != ignore], tupleind=1
-                    )
+                self.user.begin_filter_progress()
+                try:
+                    if ignore is None:
+                        dlist = self.search.apply(
+                            cdb, allkeys, tupleind=1, user=self.user
+                        )
+                    else:
+                        dlist = self.search.apply(
+                            cdb,
+                            [k for k in allkeys if k[1] != ignore],
+                            tupleind=1,
+                            user=self.user,
+                        )
+                finally:
+                    self.user.end_filter_progress()
             elif ignore is None:
                 ident = True
                 dlist = allkeys