Merge pull request #2839 from zas/fix_slowdown

Fix plugin search slowdown with multi-layered caching

Author: zas

picard/plugin3/manager.py

@@ -1469,21 +1469,33 @@ def check_updates(self):
 
         return updates
 
-    def get_plugin_update_status(self, plugin):
+    def get_plugin_update_status(self, plugin, force_refresh=False):
         """Check if a single plugin has an update available."""
+        log.debug("Checking update status for plugin: %s", plugin.plugin_id)
+
         if not plugin.manifest or not plugin.manifest.uuid:
             return False
 
         metadata = self._metadata.get_plugin_metadata(plugin.manifest.uuid)
         if not metadata or not metadata.url:
             return False
 
+        current_ref = metadata.ref or 'main'
+
+        # Try cached result first (unless force refresh)
+        if not force_refresh:
+            cached_result = self._refs_cache.get_cached_update_status(plugin.plugin_id, current_ref)
+            if cached_result is not None:
+                log.debug("Using cached update status for plugin: %s", plugin.plugin_id)
+                return cached_result
+
         try:
             backend = git_backend()
             repo = backend.create_repository(plugin.local_path)
             current_commit = repo.get_head_target()
 
             # Fetch without updating (suppress progress output)
+            log.debug("Making network request for plugin: %s", plugin.plugin_id)
             callbacks = backend.create_remote_callbacks()
             for remote in repo.get_remotes():
                 repo.fetch_remote(remote, None, callbacks._callbacks)
@@ -1549,13 +1561,18 @@ def get_plugin_update_status(self, plugin):
                 return False
 
             repo.free()
-            return current_commit != latest_commit
+            has_update = current_commit != latest_commit
+            # Cache the result with current ref
+            self._refs_cache.cache_update_status(plugin.plugin_id, has_update, current_ref)
+            return has_update
         except KeyError:
             # Ref not found, no update available
+            self._refs_cache.cache_update_status(plugin.plugin_id, False, current_ref)
             return False
         except Exception as e:
             # Log unexpected errors
             log.warning("Failed to check update for plugin %s: %s", plugin.plugin_id, e)
+            # Don't cache errors
             return False
 
     def get_plugin_remote_url(self, plugin):

picard/plugin3/refs_cache.py

@@ -395,3 +395,35 @@ def update_cache_from_local_repo(self, repo_path, url, versioning_scheme):
         except Exception as e:
             log.debug('Failed to update cache from local repo: %s', e)
             return []
+
+    def cache_update_status(self, plugin_id, has_update, current_ref=None):
+        """Cache update status for a plugin."""
+        cache = self.load_cache()
+        if 'update_status' not in cache:
+            cache['update_status'] = {}
+
+        cache['update_status'][plugin_id] = {
+            'has_update': has_update,
+            'current_ref': current_ref,
+            'timestamp': time.time(),
+        }
+        self.save_cache(cache)
+
+    def get_cached_update_status(self, plugin_id, current_ref=None, ttl=REFS_CACHE_TTL):
+        """Get cached update status for a plugin."""
+        cache = self.load_cache()
+        update_cache = cache.get('update_status', {})
+
+        if plugin_id not in update_cache:
+            return None
+
+        entry = update_cache[plugin_id]
+
+        # Check if ref has changed (invalidates cache)
+        if current_ref and entry.get('current_ref') != current_ref:
+            return None
+
+        if time.time() - entry['timestamp'] > ttl:
+            return None  # Expired
+
+        return entry['has_update']

picard/ui/options/plugins3.py

@@ -20,6 +20,7 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 
 from datetime import datetime
+from functools import partial
 
 from PyQt6 import QtCore, QtWidgets
 
@@ -86,7 +87,7 @@ def setup_ui(self):
 
         self.refresh_button = QtWidgets.QPushButton(_("Refresh List"))
         self.refresh_button.setToolTip(_("Refresh the plugin list to reflect current state"))
-        self.refresh_button.clicked.connect(self.load)
+        self.refresh_button.clicked.connect(self._refresh_list)
         toolbar_layout.addWidget(self.refresh_button)
 
         toolbar_layout.addStretch()
@@ -157,6 +158,13 @@ def load(self):
         except Exception as e:
             self._show_status(_("Error loading plugins: {}").format(str(e)))
 
+    def _refresh_list(self):
+        """Refresh plugin list and update status."""
+        self.load()
+        # Also refresh update status
+        self.plugin_list.refresh_update_status()
+        self._filter_plugins()  # Refresh display to show update indicators
+
     def _show_disabled_state(self):
         """Show UI when plugin system is disabled."""
         self.plugin_list.clear()
@@ -215,7 +223,12 @@ def _update_details_button_text(self):
 
     def _on_plugin_selected(self, plugin):
         """Handle plugin selection."""
-        self.plugin_details.show_plugin(plugin)
+        # Get cached update status to avoid network call
+        has_update = None
+        if plugin and hasattr(self.plugin_list, '_update_status_cache'):
+            has_update = self.plugin_list._update_status_cache.get(plugin.plugin_id)
+
+        self.plugin_details.show_plugin(plugin, has_update)
         # Update button text since details are now shown
         self._update_details_button_text()
 
@@ -254,6 +267,10 @@ def _check_for_updates(self):
             # Use the manager's check_updates method (which handles versioning schemes correctly)
             updates = self.plugin_manager.check_updates()
 
+            # Refresh update status in UI after checking
+            self.plugin_list.refresh_update_status()
+            self._filter_plugins()  # Refresh display to show update indicators
+
             if updates:
                 # Convert UpdateCheck objects to plugins for the dialog
                 plugins_with_updates = []
@@ -296,7 +313,9 @@ def _refresh_registry(self):
 
             # Reload the page to show updated registry data (but don't overwrite status)
             self.all_plugins = self.plugin_manager.plugins
-            self._filter_plugins()
+            # Refresh update status after registry refresh
+            self.plugin_list.refresh_update_status()
+            self._filter_plugins()  # Refresh display to show update indicators
             self._show_enabled_state()
             # Update tooltip with fresh registry info
             self._update_registry_tooltip()
@@ -376,7 +395,9 @@ def _update_next_plugin(self, async_manager):
             self.check_updates_button.setEnabled(True)
             self.install_button.setEnabled(True)
             self._show_status(_("All plugin updates completed"))
-            self.load()  # Refresh plugin list
+            # Refresh update status after batch updates
+            self.plugin_list.refresh_update_status()
+            self._filter_plugins()  # Refresh display to show updated status
             return
 
         plugin = self._update_queue.pop(0)
@@ -385,10 +406,10 @@ def _update_next_plugin(self, async_manager):
         async_manager.update_plugin(
             plugin=plugin,
             progress_callback=None,
-            callback=lambda result, am=async_manager: self._on_plugin_update_complete(result, am),
+            callback=partial(self._on_plugin_update_complete, async_manager),
         )
 
-    def _on_plugin_update_complete(self, result, async_manager):
+    def _on_plugin_update_complete(self, async_manager, result):
         """Handle individual plugin update completion."""
         if not result.success:
             error_msg = str(result.error) if result.error else _("Unknown error")

picard/ui/widgets/plugindetailswidget.py

@@ -19,6 +19,8 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 
+from functools import partial
+
 from PyQt6 import QtCore, QtGui, QtWidgets
 
 from picard.i18n import gettext as _
@@ -119,8 +121,13 @@ def setup_ui(self):
         # Initially hide everything
         self.setVisible(False)
 
-    def show_plugin(self, plugin):
-        """Show details for the given plugin."""
+    def show_plugin(self, plugin, has_update=None):
+        """Show details for the given plugin.
+
+        Args:
+            plugin: Plugin to show
+            has_update: Optional cached update status to avoid network call
+        """
         self.current_plugin = plugin
 
         if plugin is None:
@@ -154,8 +161,12 @@ def show_plugin(self, plugin):
         self.git_ref_label.setText(self._get_git_ref_display(plugin))
         self.git_url_label.setText(self._get_git_url_display(plugin))
 
-        # Check if update is available and enable/disable update button
-        self.update_button.setEnabled(self._has_update_available(plugin))
+        # Check if update is available - use cached value if provided, otherwise disable button
+        if has_update is not None:
+            self.update_button.setEnabled(has_update)
+        else:
+            # Don't check for updates during normal display to avoid network calls
+            self.update_button.setEnabled(False)
 
         # Enable/disable description button based on long description availability
         has_long_desc = self.plugin_manager.long_description_as_html(plugin) is not None
@@ -240,13 +251,12 @@ def _uninstall_plugin(self):
             # Fallback to old method if plugin list not found
             self._perform_uninstall()
 
-    def _on_uninstall_complete(self, result):
+    def _on_uninstall_complete(self, plugin, result):
         """Handle uninstall completion."""
         if result.success:
             # Emit the same signal as context menu for status updates
-            if hasattr(self, '_uninstalling_plugin') and hasattr(self.parent(), 'plugin_state_changed'):
-                self.parent().plugin_state_changed.emit(self._uninstalling_plugin, "uninstalled")
-                delattr(self, '_uninstalling_plugin')
+            if hasattr(self.parent(), 'plugin_state_changed'):
+                self.parent().plugin_state_changed.emit(plugin, "uninstalled")
             self.show_plugin(None)  # Clear details
             self.plugin_uninstalled.emit()  # Signal that plugin was uninstalled
         else:
@@ -360,10 +370,11 @@ def _perform_uninstall(self):
         dialog = UninstallPluginDialog(self.current_plugin, self)
         if dialog.exec() == QtWidgets.QDialog.DialogCode.Accepted:
             try:
-                self._uninstalling_plugin = self.current_plugin  # Store for callback
                 async_manager = AsyncPluginManager(self.plugin_manager)
                 async_manager.uninstall_plugin(
-                    self.current_plugin, purge=dialog.purge_config, callback=self._on_uninstall_complete
+                    self.current_plugin,
+                    purge=dialog.purge_config,
+                    callback=partial(self._on_uninstall_complete, self.current_plugin),
                 )
             except Exception as e:
                 QtWidgets.QMessageBox.critical(
@@ -378,20 +389,22 @@ def _perform_update(self):
 
         async_manager = AsyncPluginManager(self.plugin_manager)
         async_manager.update_plugin(
-            plugin=self.current_plugin, progress_callback=None, callback=self._on_update_complete
+            plugin=self.current_plugin,
+            progress_callback=None,
+            callback=partial(self._on_update_complete, self.current_plugin),
         )
 
-    def _on_update_complete(self, result):
+    def _on_update_complete(self, plugin, result):
         """Handle update completion."""
         self.update_button.setText(_("Update"))
 
         if result.success:
             self.plugin_updated.emit()  # Signal that plugin was updated
             # Emit the same signal as context menu for status updates
             if hasattr(self.parent(), 'plugin_state_changed'):
-                self.parent().plugin_state_changed.emit(self.current_plugin, "updated")
-            # Refresh the display
-            self.show_plugin(self.current_plugin)
+                self.parent().plugin_state_changed.emit(plugin, "updated")
+            # Refresh the display - plugin should no longer have update available
+            self.show_plugin(plugin, False)
         else:
             self.update_button.setEnabled(True)
             error_msg = str(result.error) if result.error else _("Unknown error")