oqtopus 0.2.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

oqtopus/gui/main_dialog.py

@@ -24,6 +24,7 @@
 
 
 import os
+import shutil
 import sys
 
 from qgis.PyQt.QtCore import QUrl
@@ -31,8 +32,10 @@ from qgis.PyQt.QtGui import QAction, QDesktopServices
 from qgis.PyQt.QtWidgets import (
     QDialog,
     QMenuBar,
+    QMessageBox,
 )
 
+from ..core.module_package import ModulePackage
 from ..utils.plugin_utils import PluginUtils, logger
 from .about_dialog import AboutDialog
 from .settings_dialog import SettingsDialog
@@ -93,10 +96,18 @@ class MainDialog(QDialog, DIALOG_UI):
             self.menubar.setNativeMenuBar(False)
         self.layout().setMenuBar(self.menubar)
 
-        # Settings action
-        settings_action = QAction(self.tr("Settings"), self)
-        settings_action.triggered.connect(self.__open_settings_dialog)
-        self.menubar.addAction(settings_action)
+        # Settings menu
+        settings_menu = self.menubar.addMenu(self.tr("Settings"))
+
+        # Settings dialog action
+        settings_dialog_action = QAction(self.tr("Preferences..."), self)
+        settings_dialog_action.triggered.connect(self.__open_settings_dialog)
+        settings_menu.addAction(settings_dialog_action)
+
+        # Cache cleanup action
+        cleanup_cache_action = QAction(self.tr("Cleanup Cache"), self)
+        cleanup_cache_action.triggered.connect(self.__cleanup_cache)
+        settings_menu.addAction(cleanup_cache_action)
 
         # Help menu
         help_menu = self.menubar.addMenu(self.tr("Help"))
@@ -127,13 +138,34 @@ class MainDialog(QDialog, DIALOG_UI):
         )
         self.__databaseConnectionWidget_connectionChanged()
 
-        self.module_tab.setEnabled(False)
-        self.plugin_tab.setEnabled(False)
-        self.project_tab.setEnabled(False)
+        self.__disable_module_tabs()
 
         logger.info("Ready.")
 
+    def closeEvent(self, event):
+        """Handle window close event (X button) to properly cleanup threads."""
+        if self.__moduleWidget.isOperationRunning():
+            QMessageBox.warning(
+                self,
+                self.tr("Operation in progress"),
+                self.tr("Cannot close the dialog while an operation is running."),
+            )
+            event.ignore()
+            return
+        self.__moduleWidget.close()
+        self.__moduleSelectionWidget.close()
+        self.__logsWidget.close()
+        event.accept()
+
     def __closeDialog(self):
+        if self.__moduleWidget.isOperationRunning():
+            QMessageBox.warning(
+                self,
+                self.tr("Operation in progress"),
+                self.tr("Cannot close the dialog while an operation is running."),
+            )
+            return
+        self.__moduleWidget.close()
         self.__moduleSelectionWidget.close()
         self.__logsWidget.close()
         self.accept()
@@ -147,44 +179,99 @@ class MainDialog(QDialog, DIALOG_UI):
         dlg = SettingsDialog(self)
         dlg.exec()
 
+    def __cleanup_cache(self):
+        """Delete all cached data (downloaded packages and GitHub API cache)."""
+        cache_paths = PluginUtils.get_all_cache_paths()
+
+        if not cache_paths:
+            QMessageBox.information(
+                self,
+                self.tr("Cache Cleanup"),
+                self.tr("No cache directories found. Nothing to clean up."),
+            )
+            return
+
+        # Format paths for display
+        paths_display = "\n".join(f"  • {p}" for p in cache_paths)
+
+        # Ask for confirmation
+        reply = QMessageBox.question(
+            self,
+            self.tr("Cleanup Cache"),
+            self.tr(
+                f"This will delete all cached data from:\n{paths_display}\n\n"
+                "Downloaded module packages and API cache will need to be re-fetched.\n\n"
+                "Are you sure you want to continue?"
+            ),
+            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
+            QMessageBox.StandardButton.No,
+        )
+
+        if reply != QMessageBox.StandardButton.Yes:
+            return
+
+        errors = []
+        for cache_dir in cache_paths:
+            try:
+                shutil.rmtree(cache_dir)
+            except Exception as e:
+                errors.append(f"{cache_dir}: {e}")
+
+        if errors:
+            QMessageBox.warning(
+                self,
+                self.tr("Cache Cleanup Warning"),
+                self.tr("Some cache directories could not be deleted:\n") + "\n".join(errors),
+            )
+        else:
+            QMessageBox.information(
+                self,
+                self.tr("Cache Cleanup"),
+                self.tr("Cache has been successfully cleaned up."),
+            )
+
     def __show_about_dialog(self):
         dialog = self.__about_dialog_cls(self)
         dialog.exec()
 
-    def __moduleSelection_loadingStarted(self):
-        self.db_groupBox.setEnabled(False)
+    def __disable_module_tabs(self):
+        """Disable all module-related tabs."""
         self.module_tab.setEnabled(False)
         self.plugin_tab.setEnabled(False)
         self.project_tab.setEnabled(False)
 
-    def __moduleSelection_loadingFinished(self):
-        self.db_groupBox.setEnabled(True)
-
-        module_package = self.__moduleSelectionWidget.getSelectedModulePackage()
-        if module_package is None:
-            return
+    def __enable_module_tabs(self, module_package: ModulePackage):
+        """Enable module tabs based on available assets."""
+        self.module_tab.setEnabled(True)
+        self.plugin_tab.setEnabled(module_package.asset_plugin is not None)
+        self.project_tab.setEnabled(module_package.asset_project is not None)
 
-        if self.__moduleSelectionWidget.lastError() is not None:
-            return
+    def __clear_module_packages(self):
+        """Clear module package state from all widgets."""
+        self.__moduleWidget.clearModulePackage()
+        self.__projectWidget.clearModulePackage()
+        self.__pluginWidget.clearModulePackage()
 
-        self.module_tab.setEnabled(True)
+    def __set_module_packages(self, module_package: ModulePackage):
+        """Set module package in all widgets."""
+        self.__moduleWidget.setModulePackage(module_package)
+        self.__projectWidget.setModulePackage(module_package)
+        self.__pluginWidget.setModulePackage(module_package)
 
-        if module_package.asset_plugin is not None:
-            self.plugin_tab.setEnabled(True)
+    def __moduleSelection_loadingStarted(self):
+        self.db_groupBox.setEnabled(False)
+        self.__disable_module_tabs()
+        self.__clear_module_packages()
 
-        if module_package.asset_project is not None:
-            self.project_tab.setEnabled(True)
+    def __moduleSelection_loadingFinished(self):
+        self.db_groupBox.setEnabled(True)
 
-        self.__moduleWidget.setModulePackage(
-            self.__moduleSelectionWidget.getSelectedModulePackage()
-        )
-        self.__projectWidget.setModulePackage(
-            self.__moduleSelectionWidget.getSelectedModulePackage()
-        )
+        module_package = self.__moduleSelectionWidget.getSelectedModulePackage()
+        if module_package is None or self.__moduleSelectionWidget.lastError() is not None:
+            return
 
-        self.__pluginWidget.setModulePackage(
-            self.__moduleSelectionWidget.getSelectedModulePackage()
-        )
+        self.__enable_module_tabs(module_package)
+        self.__set_module_packages(module_package)
 
     def __databaseConnectionWidget_connectionChanged(self):
         self.__moduleWidget.setDatabaseConnection(self.__databaseConnectionWidget.getConnection())

oqtopus/gui/module_selection_widget.py

@@ -15,7 +15,7 @@ DIALOG_UI = PluginUtils.get_ui_class("module_selection_widget.ui")
 
 class ModuleSelectionWidget(QWidget, DIALOG_UI):
 
-    module_package_SPECIAL_LOAD_DEVELOPMENT = "Load development versions"
+    module_package_SPECIAL_LOAD_DEVELOPMENT = "Load pre-releases and development branches"
 
     signal_loadingStarted = pyqtSignal()
     signal_loadingFinished = pyqtSignal()
@@ -49,8 +49,10 @@ class ModuleSelectionWidget(QWidget, DIALOG_UI):
             for config_module in self.__modules_config.modules:
                 module = Module(
                     name=config_module.name,
+                    id=config_module.id,
                     organisation=config_module.organisation,
                     repository=config_module.repository,
+                    exclude_releases=config_module.exclude_releases,
                     parent=self,
                 )
                 self.module_module_comboBox.addItem(module.name, module)
@@ -62,8 +64,8 @@ class ModuleSelectionWidget(QWidget, DIALOG_UI):
         self.module_latestVersion_label.setText("")
         QtUtils.setForegroundColor(self.module_latestVersion_label, PluginUtils.COLOR_GREEN)
 
-        self.module_package_comboBox.clear()
-        self.module_package_comboBox.addItem(self.tr("Please select a version"), None)
+        self.__reset_package_selection()
+        self.module_seeChangeLog_pushButton.setEnabled(False)
 
         self.module_zipPackage_groupBox.setVisible(False)
 
@@ -80,6 +82,14 @@ class ModuleSelectionWidget(QWidget, DIALOG_UI):
 
     def close(self):
         if self.__packagePrepareTask.isRunning():
+            # Disconnect signals first to prevent crashes when emitting to destroyed widgets
+            try:
+                self.__packagePrepareTask.signalPackagingProgress.disconnect()
+                self.__packagePrepareTask.finished.disconnect()
+            except TypeError:
+                # Already disconnected
+                pass
+
             self.__packagePrepareTask.cancel()
             self.__packagePrepareTask.wait()
 
@@ -93,22 +103,51 @@ class ModuleSelectionWidget(QWidget, DIALOG_UI):
         """
         return self.__packagePrepareTask.lastError
 
+    def __reset_package_selection(self):
+        """Reset package selection combo box to initial state."""
+        self.module_package_comboBox.clear()
+        self.module_package_comboBox.addItem(self.tr("Please select a version"), None)
+        self.module_package_comboBox.setEnabled(False)
+        # Disable this placeholder item so it can't be selected once a version is chosen
+        model = self.module_package_comboBox.model()
+        item = model.item(0)
+        if item:
+            item.setEnabled(False)
+
+    def __enable_package_selection(self):
+        """Enable package selection combo box."""
+        self.module_package_comboBox.setEnabled(True)
+
     def __moduleChanged(self, index):
+        logger.debug(f"__moduleChanged START, index={index}")
         if self.module_module_comboBox.currentData() == self.__current_module:
+            logger.debug("Same module selected, returning")
             return
 
+        logger.debug(f"Module changed to: {self.module_module_comboBox.currentText()}")
         self.__current_module = self.module_module_comboBox.currentData()
 
+        logger.debug("Resetting labels and UI")
         self.module_latestVersion_label.setText("")
-        self.module_package_comboBox.clear()
-        self.module_package_comboBox.addItem(self.tr("Please select a version"), None)
+        self.__reset_package_selection()
+        self.module_seeChangeLog_pushButton.setEnabled(False)
 
         if self.__current_module is None:
+            logger.debug("No module selected")
             return
 
+        logger.debug(f"Module versions list length: {len(self.__current_module.versions)}")
         if self.__current_module.versions == list():
+            logger.debug("Versions empty, starting load")
+            # Emit signal first to allow UI to update before showing wait cursor
+            self.signal_loadingStarted.emit()
             QApplication.setOverrideCursor(Qt.CursorShape.WaitCursor)
             self.__current_module.start_load_versions()
+        else:
+            logger.debug("Versions already loaded, populating UI")
+            # Versions already loaded (from cache or previous selection) - populate UI
+            self.__loadVersionsFinished("")
+        logger.debug("__moduleChanged END")
 
     def __moduleVersionChanged(self, index):
 
@@ -126,20 +165,35 @@ class ModuleSelectionWidget(QWidget, DIALOG_UI):
 
         self.__current_module_package = self.module_package_comboBox.currentData()
         if self.__current_module_package is None:
+            self.module_seeChangeLog_pushButton.setEnabled(False)
+            # Clear module information when placeholder is selected
+            self.module_information_label.setText(self.tr("Please select a version"))
+            QtUtils.resetForegroundColor(self.module_information_label)
+            self.module_informationProject_label.setText("-")
+            self.module_informationPlugin_label.setText("-")
+            # Emit signal to clear module widgets
+            self.signal_loadingFinished.emit()
             return
 
+        # Enable changelog button for valid selections
+        self.module_seeChangeLog_pushButton.setEnabled(True)
+
         if self.__current_module_package.type == self.__current_module_package.Type.FROM_ZIP:
             self.module_zipPackage_groupBox.setVisible(True)
             return
         else:
             self.module_zipPackage_groupBox.setVisible(False)
 
-        loading_text = self.tr(
-            f"Loading packages for module '{self.module_module_comboBox.currentText()}' version '{self.__current_module_package.display_name()}'..."
-        )
+        loading_text = self.tr("Loading package...")
         self.module_information_label.setText(loading_text)
+        self.module_information_label.setToolTip(
+            f"{self.module_module_comboBox.currentText()} - {self.__current_module_package.display_name()}"
+        )
         QtUtils.resetForegroundColor(self.module_information_label)
-        logger.info(loading_text)
+        logger.info(
+            f"Loading packages for module '{self.module_module_comboBox.currentText()}' "
+            f"version '{self.__current_module_package.display_name()}'..."
+        )
 
         self.module_informationProject_label.setText("-")
         self.module_informationPlugin_label.setText("-")
@@ -147,6 +201,8 @@ class ModuleSelectionWidget(QWidget, DIALOG_UI):
         self.__packagePrepareTask.startFromModulePackage(self.__current_module_package)
 
         self.signal_loadingStarted.emit()
+        self.module_progressBar.setMaximum(100)
+        self.module_progressBar.setValue(0)
         self.module_progressBar.setVisible(True)
 
     def __loadDevelopmentVersions(self):
@@ -154,6 +210,8 @@ class ModuleSelectionWidget(QWidget, DIALOG_UI):
             return
 
         if self.__current_module.development_versions == list():
+            # Emit signal first to allow UI to update before showing wait cursor
+            self.signal_loadingStarted.emit()
             QApplication.setOverrideCursor(Qt.CursorShape.WaitCursor)
             self.__current_module.start_load_development_versions()
 
@@ -185,6 +243,8 @@ class ModuleSelectionWidget(QWidget, DIALOG_UI):
         self.__packagePrepareTask.startFromZip(self.__current_module_package, filename)
 
         self.signal_loadingStarted.emit()
+        self.module_progressBar.setMaximum(100)
+        self.module_progressBar.setValue(0)
         self.module_progressBar.setVisible(True)
 
     def __packagePrepareTaskFinished(self):
@@ -211,29 +271,43 @@ class ModuleSelectionWidget(QWidget, DIALOG_UI):
         package_dir = self.module_package_comboBox.currentData().source_package_dir
         logger.info(f"Package loaded into '{package_dir}'")
         QtUtils.resetForegroundColor(self.module_information_label)
-        self.module_information_label.setText(
-            f"<a href='file://{package_dir}'>{package_dir}</a>",
-        )
+        QtUtils.setPathLinkWithEllipsis(self.module_information_label, package_dir)
 
         asset_project = self.module_package_comboBox.currentData().asset_project
         if asset_project:
-            self.module_informationProject_label.setText(
-                f"<a href='file://{asset_project.package_dir}'>{asset_project.package_dir}</a>",
+            QtUtils.setPathLinkWithEllipsis(
+                self.module_informationProject_label, asset_project.package_dir
             )
         else:
             self.module_informationProject_label.setText("No asset available")
+            self.module_informationProject_label.setToolTip("")
 
         asset_plugin = self.module_package_comboBox.currentData().asset_plugin
         if asset_plugin:
-            self.module_informationPlugin_label.setText(
-                f"<a href='file://{asset_plugin.package_dir}'>{asset_plugin.package_dir}</a>",
+            QtUtils.setPathLinkWithEllipsis(
+                self.module_informationPlugin_label, asset_plugin.package_dir
             )
         else:
             self.module_informationPlugin_label.setText("No asset available")
+            self.module_informationPlugin_label.setToolTip("")
+
+    def __packagePrepareTaskProgress(self, progress, bytes_downloaded):
+        if progress < 0:
+            # Indeterminate progress (size unknown)
+            self.module_progressBar.setMaximum(0)
+            self.module_progressBar.setValue(0)
+            if bytes_downloaded > 0:
+                mb_downloaded = bytes_downloaded / (1024 * 1024)
+                loading_text = self.tr(f"Downloading package... {mb_downloaded:.1f} MB")
+            else:
+                loading_text = self.tr("Downloading package...")
+        else:
+            # Determinate progress (0-100%)
+            self.module_progressBar.setMaximum(100)
+            self.module_progressBar.setValue(int(progress))
+            mb_downloaded = bytes_downloaded / (1024 * 1024)
+            loading_text = self.tr(f"Downloading... {mb_downloaded:.1f} MB ({progress:.0f}%)")
 
-    def __packagePrepareTaskProgress(self, progress):
-        loading_text = self.tr("Load package task running...")
-        logger.info(loading_text)
         self.module_information_label.setText(loading_text)
 
     def __seeChangeLogClicked(self):
@@ -300,6 +374,9 @@ class ModuleSelectionWidget(QWidget, DIALOG_UI):
             return
 
         for module_package in self.__current_module.versions:
+            # Skip pre-releases in the main list (they'll be shown in development versions)
+            if module_package.prerelease is True:
+                continue
             self.module_package_comboBox.addItem(module_package.display_name(), module_package)
 
         if self.__current_module.latest_version is not None:
@@ -321,10 +398,19 @@ class ModuleSelectionWidget(QWidget, DIALOG_UI):
         )
 
         self.module_package_comboBox.insertSeparator(self.module_package_comboBox.count())
-        self.module_package_comboBox.addItem(
-            self.tr("Load development branches"), self.module_package_SPECIAL_LOAD_DEVELOPMENT
-        )
 
+        # If development versions were already loaded, add them directly
+        # Otherwise show the option to load them
+        if self.__current_module.development_versions:
+            for module_package in self.__current_module.development_versions:
+                self.module_package_comboBox.addItem(module_package.display_name(), module_package)
+        else:
+            self.module_package_comboBox.addItem(
+                self.tr("Load pre-releases and development branches"),
+                self.module_package_SPECIAL_LOAD_DEVELOPMENT,
+            )
+
+        self.__enable_package_selection()
         self.module_progressBar.setVisible(False)
         logger.info(f"Versions loaded for module '{self.__current_module.name}'.")
 
@@ -373,3 +459,5 @@ class ModuleSelectionWidget(QWidget, DIALOG_UI):
 
         for module_package in self.__current_module.development_versions:
             self.module_package_comboBox.addItem(module_package.display_name(), module_package)
+
+        self.__enable_package_selection()