oqtopus 0.1.14__py3-none-any.whl

oqtopus/gui/project_widget.py

@@ -0,0 +1,170 @@
+import os
+import shutil
+
+from qgis.PyQt.QtWidgets import QFileDialog, QMessageBox, QWidget
+
+from ..core.module_package import ModulePackage
+from ..utils.plugin_utils import PluginUtils
+from ..utils.qt_utils import CriticalMessageBox, QtUtils
+
+DIALOG_UI = PluginUtils.get_ui_class("project_widget.ui")
+
+
+class ProjectWidget(QWidget, DIALOG_UI):
+
+    def __init__(self, parent=None):
+        QWidget.__init__(self, parent)
+        self.setupUi(self)
+
+        self.project_install_pushButton.clicked.connect(self.__projectInstallClicked)
+        self.project_seeChangelog_pushButton.clicked.connect(self.__projectSeeChangelogClicked)
+
+        self.__current_module_package = None
+
+    def setModulePackage(self, module_package: ModulePackage):
+        self.__current_module_package = module_package
+        self.__packagePrepareGetProjectFilename()
+
+    def __packagePrepareGetProjectFilename(self):
+        asset_project = self.__current_module_package.asset_project
+        if asset_project is None:
+            self.project_info_label.setText(
+                self.tr("No project asset available for this module version.")
+            )
+            QtUtils.setForegroundColor(self.project_info_label, PluginUtils.COLOR_WARNING)
+            QtUtils.setFontItalic(self.project_info_label, True)
+            return
+
+        # Search for QGIS project file in self.__package_dir
+        project_file_dir = os.path.join(asset_project.package_dir, "project")
+
+        # Check if the directory exists
+        if not os.path.exists(project_file_dir):
+            self.project_info_label.setText(
+                self.tr(f"Project directory '{project_file_dir}' does not exist.")
+            )
+            QtUtils.setForegroundColor(self.project_info_label, PluginUtils.COLOR_WARNING)
+            QtUtils.setFontItalic(self.project_info_label, True)
+            return
+
+        self.__project_file = None
+        for root, dirs, files in os.walk(project_file_dir):
+            for file in files:
+                if file.endswith(".qgz") or file.endswith(".qgs"):
+                    self.__project_file = os.path.join(root, file)
+                    break
+
+            if self.__project_file:
+                break
+
+        if self.__project_file is None:
+            self.project_info_label.setText(
+                self.tr(f"No QGIS project file (.qgz or .qgs) found into {project_file_dir}."),
+            )
+            QtUtils.setForegroundColor(self.project_info_label, PluginUtils.COLOR_WARNING)
+            QtUtils.setFontItalic(self.db_database_label, True)
+            return
+
+        self.project_info_label.setText(
+            self.tr(self.__project_file),
+        )
+        QtUtils.setForegroundColor(self.project_info_label, PluginUtils.COLOR_GREEN)
+        QtUtils.setFontItalic(self.db_database_label, False)
+
+    def __projectInstallClicked(self):
+
+        if self.__current_module_package is None:
+            QMessageBox.warning(
+                self,
+                self.tr("Error"),
+                self.tr("Please select a module and version first."),
+            )
+            return
+
+        if self.module_package_comboBox.currentData() is None:
+            QMessageBox.warning(
+                self,
+                self.tr("Error"),
+                self.tr("Please select a module version first."),
+            )
+            return
+
+        asset_project = self.module_package_comboBox.currentData().asset_project
+        if asset_project is None:
+            QMessageBox.warning(
+                self,
+                self.tr("Error"),
+                self.tr("No project asset available for this module version."),
+            )
+            return
+
+        package_dir = asset_project.package_dir
+        if package_dir is None:
+            CriticalMessageBox(
+                self.tr("Error"), self.tr("No valid package directory available."), None, self
+            ).exec()
+            return
+
+        # Search for QGIS project file in package_dir
+        project_file_dir = os.path.join(package_dir, "project")
+
+        # Check if the directory exists
+        if not os.path.exists(project_file_dir):
+            CriticalMessageBox(
+                self.tr("Error"),
+                self.tr(f"Project directory '{project_file_dir}' does not exist."),
+                None,
+                self,
+            ).exec()
+            return
+
+        self.__project_file = None
+        for root, dirs, files in os.walk(project_file_dir):
+            print(f"Searching for QGIS project file in {root}: {files}")
+            for file in files:
+                if file.endswith(".qgz") or file.endswith(".qgs"):
+                    self.__project_file = os.path.join(root, file)
+                    break
+
+            if self.__project_file:
+                break
+
+        if self.__project_file is None:
+            CriticalMessageBox(
+                self.tr("Error"),
+                self.tr(f"No QGIS project file (.qgz or .qgs) found into {project_file_dir}."),
+                None,
+                self,
+            ).exec()
+            return
+
+        install_destination = QFileDialog.getExistingDirectory(
+            self,
+            self.tr("Select installation directory"),
+            "",
+            QFileDialog.Option.ShowDirsOnly,
+        )
+
+        if not install_destination:
+            return
+
+        # Copy the project file to the selected directory
+        try:
+            shutil.copy(self.__project_file, install_destination)
+            QMessageBox.information(
+                self,
+                self.tr("Project installed"),
+                self.tr(
+                    f"Project file '{self.__project_file}' has been copied to '{install_destination}'."
+                ),
+            )
+        except Exception as e:
+            QMessageBox.critical(
+                self,
+                self.tr("Error"),
+                self.tr(f"Failed to copy project file: {e}"),
+            )
+            return
+
+    def __projectSeeChangelogClicked(self):
+        self.__seeChangeLogClicked()

oqtopus/gui/settings_dialog.py

@@ -0,0 +1,37 @@
+from qgis.PyQt.QtWidgets import QApplication, QDialog, QMessageBox, QStyle
+
+from ..utils.plugin_utils import PluginUtils
+
+DIALOG_UI = PluginUtils.get_ui_class("settings_dialog.ui")
+
+
+class SettingsDialog(QDialog, DIALOG_UI):
+    def __init__(self, parent=None):
+        QDialog.__init__(self, parent)
+        self.setupUi(self)
+
+        self.githubToken_lineEdit.setText(PluginUtils.get_github_token())
+
+        self.helpButton.setIcon(
+            QApplication.style().standardIcon(QStyle.StandardPixmap.SP_DialogHelpButton)
+        )
+        self.helpButton.clicked.connect(self.__show_github_token_help)
+
+    def accept(self):
+        PluginUtils.set_github_token(self.githubToken_lineEdit.text())
+        super().accept()
+
+    def __show_github_token_help(self):
+        QMessageBox.information(
+            self,
+            "GitHub Access Token Help",
+            "<b>GitHub Access Token</b><br>"
+            "Oqtopus needs to download release data from GitHub to work properly. "
+            "GitHub limits the number of requests that can be made without authentication. "
+            "A personal access token is required to access private repositories or to increase API rate limits.<br><br>"
+            "To generate a token:<br>"
+            "1. Go to <a href='https://github.com/settings/tokens'>GitHub Personal Access Tokens</a>.<br>"
+            "2. Click <b>Generate new token</b>.<br>"
+            "3. Select the <code>repo</code> scope for most operations.<br>"
+            "4. Copy and paste the generated token here.",
+        )

oqtopus/oqtopus.py

@@ -0,0 +1,67 @@
+import sys
+import types
+from pathlib import Path
+
+import yaml
+
+# Create fake qgis.PyQt modules that point to PyQt5 modules
+try:
+    pyqt_core = __import__("PyQt6.QtCore", fromlist=[""])
+    pyqt_gui = __import__("PyQt6.QtGui", fromlist=[""])
+    pyqt_network = __import__("PyQt6.QtNetwork", fromlist=[""])
+    pyqt_widgets = __import__("PyQt6.QtWidgets", fromlist=[""])
+    pyqt_uic = __import__("PyQt6.uic", fromlist=[""])
+except ModuleNotFoundError:
+    pyqt_core = __import__("PyQt5.QtCore", fromlist=[""])
+    pyqt_gui = __import__("PyQt5.QtGui", fromlist=[""])
+    pyqt_network = __import__("PyQt5.QtNetwork", fromlist=[""])
+    pyqt_widgets = __import__("PyQt5.QtWidgets", fromlist=[""])
+    pyqt_uic = __import__("PyQt5.uic", fromlist=[""])
+
+# Create the qgis, qgis.PyQt, and submodules in sys.modules
+qgis = types.ModuleType("qgis")
+pyqt = types.ModuleType("qgis.PyQt")
+pyqt.QtCore = pyqt_core
+pyqt.QtGui = pyqt_gui
+pyqt.QtNetwork = pyqt_network
+pyqt.QtWidgets = pyqt_widgets
+pyqt.uic = pyqt_uic
+
+qgis.PyQt = pyqt
+sys.modules["qgis"] = qgis
+sys.modules["qgis.PyQt"] = pyqt
+sys.modules["qgis.PyQt.QtCore"] = pyqt_core
+sys.modules["qgis.PyQt.QtGui"] = pyqt_gui
+sys.modules["qgis.PyQt.QtNetwork"] = pyqt_network
+sys.modules["qgis.PyQt.QtWidgets"] = pyqt_widgets
+sys.modules["qgis.PyQt.uic"] = pyqt_uic
+
+from qgis.PyQt.QtGui import QIcon  # noqa: E402
+
+from .core.modules_config import ModulesConfig  # noqa: E402
+from .gui.main_dialog import MainDialog  # noqa: E402
+from .utils.plugin_utils import PluginUtils  # noqa: E402
+
+
+def main():
+    app = pyqt_widgets.QApplication(sys.argv)
+    icon = QIcon("oqtopus/icons/oqtopus-logo.png")
+    app.setWindowIcon(icon)
+
+    PluginUtils.init_logger()
+
+    conf_path = Path(__file__).parent / "default_config.yaml"
+
+    with conf_path.open() as f:
+        data = yaml.safe_load(f)
+        modules_config = ModulesConfig(**data)
+
+    dialog = MainDialog(modules_config)
+    dialog.setWindowIcon(icon)
+    dialog.show()
+
+    sys.exit(app.exec())
+
+
+if __name__ == "__main__":
+    main()

oqtopus/oqtopus_plugin.py

@@ -0,0 +1,184 @@
+from pathlib import Path
+
+import yaml
+from qgis.PyQt.QtGui import QIcon
+from qgis.PyQt.QtWidgets import QAction, QApplication
+
+from oqtopus.core.modules_config import ModulesConfig
+
+from .gui.about_dialog import AboutDialog
+from .gui.main_dialog import MainDialog
+from .utils.plugin_utils import PluginUtils, logger
+
+
+class OqtopusPlugin:
+
+    def __init__(self, iface):
+        """Constructor.
+
+        :param iface: An interface instance that will be passed to this class
+            which provides the hook by which you can manipulate the QGIS
+            application at run time.
+        :type iface: QgsInterface
+        """
+        # Save reference to the QGIS interface
+        self.iface = iface
+        self.canvas = iface.mapCanvas()
+
+        self.__version__ = PluginUtils.get_plugin_version()
+
+        PluginUtils.init_logger()
+
+        logger.info("")
+        logger.info(f"Starting {PluginUtils.PLUGIN_NAME} plugin version {self.__version__}")
+
+        self.actions = []
+        self.main_menu_name = self.tr(f"&{PluginUtils.PLUGIN_NAME}")
+
+        conf_path = Path(__file__).parent / "default_config.yaml"
+
+        with conf_path.open() as f:
+            data = yaml.safe_load(f)
+            self.modules_config = ModulesConfig(**data)
+
+    # noinspection PyMethodMayBeStatic
+    def tr(self, source_text):
+        """
+        This does not inherit from QObject but for the translation to work
+        :rtype : unicode
+        :param source_text: The text to translate
+        :return: The translated text
+        """
+        # noinspection PyTypeChecker,PyArgumentList,PyCallByClass
+        return QApplication.translate("OqtopusPlugin", source_text)
+
+    def add_action(
+        self,
+        icon_path,
+        text,
+        callback,
+        enabled_flag=True,
+        add_to_menu=True,
+        add_to_toolbar=True,
+        status_tip=None,
+        whats_this=None,
+        parent=None,
+    ):
+        """Add a toolbar icon to the toolbar.
+
+        :param icon_path: Path to the icon for this action. Can be a resource
+            path (e.g. ':/plugins/foo/bar.png') or a normal file system path.
+        :type icon_path: str
+
+        :param text: Text that should be shown in menu items for this action.
+        :type text: str
+
+        :param callback: Function to be called when the action is triggered.
+        :type callback: function
+
+        :param enabled_flag: A flag indicating if the action should be enabled
+            by default. Defaults to True.
+        :type enabled_flag: bool
+
+        :param add_to_menu: Flag indicating whether the action should also
+            be added to the menu. Defaults to True.
+        :type add_to_menu: bool
+
+        :param add_to_toolbar: Flag indicating whether the action should also
+            be added to the toolbar. Defaults to True.
+        :type add_to_toolbar: bool
+
+        :param status_tip: Optional text to show in a popup when mouse pointer
+            hovers over the action.
+        :type status_tip: str
+
+        :param parent: Parent widget for the new action. Defaults None.
+        :type parent: QWidget
+
+        :param whats_this: Optional text to show in the status bar when the
+            mouse pointer hovers over the action.
+
+        :returns: The action that was created. Note that the action is also
+            added to self.actions list.
+        :rtype: QAction
+        """
+
+        icon = QIcon(icon_path)
+        action = QAction(icon, text, parent)
+        action.triggered.connect(callback)
+        action.setEnabled(enabled_flag)
+
+        if status_tip is not None:
+            action.setStatusTip(status_tip)
+
+        if whats_this is not None:
+            action.setWhatsThis(whats_this)
+
+        if add_to_toolbar:
+            # Adds plugin icon to Plugins toolbar
+            self.iface.addToolBarIcon(action)
+
+        if add_to_menu:
+            self.iface.addPluginToMenu(self.main_menu_name, action)
+
+        self.actions.append(action)
+
+        return action
+
+    def initGui(self):
+        """Create the menu entries and toolbar icons inside the QGIS GUI."""
+        self.add_action(
+            icon_path=PluginUtils.get_plugin_icon_path("oqtopus-logo.png"),
+            text=self.tr("Show &main dialog"),
+            callback=self.show_main_dialog,
+            parent=self.iface.mainWindow(),
+        )
+        self.add_action(
+            icon_path=None,
+            text=self.tr("Show &log folder"),
+            callback=self.show_logs_folder,
+            parent=self.iface.mainWindow(),
+            add_to_toolbar=False,
+        )
+        self.add_action(
+            icon_path=PluginUtils.get_plugin_icon_path("oqtopus-logo.png"),
+            text=self.tr("&About"),
+            callback=self.show_about_dialog,
+            parent=self.iface.mainWindow(),
+            add_to_toolbar=False,
+        )
+
+        self._get_main_menu_action().setIcon(
+            PluginUtils.get_plugin_icon("oqtopus-logo.png"),
+        )
+
+    def unload(self):
+        """Removes the plugin menu item and icon from QGIS GUI."""
+        for action in self.actions:
+            self.iface.removePluginMenu(self.main_menu_name, action)
+            self.iface.removeToolBarIcon(action)
+
+    def show_main_dialog(self):
+        main_dialog = MainDialog(self.modules_config, self.iface.mainWindow())
+        main_dialog.exec()
+
+    def show_logs_folder(self):
+        PluginUtils.open_logs_folder()
+
+    def show_about_dialog(self):
+        about_dialog = AboutDialog(self.iface.mainWindow())
+        about_dialog.exec()
+
+    def _get_main_menu_action(self):
+        actions = self.iface.pluginMenu().actions()
+        result_actions = [action for action in actions if action.text() == self.main_menu_name]
+
+        # OSX does not support & in the menu title
+        if not result_actions:
+            result_actions = [
+                action
+                for action in actions
+                if action.text() == self.main_menu_name.replace("&", "")
+            ]
+
+        return result_actions[0]

oqtopus/utils/plugin_utils.py

@@ -0,0 +1,172 @@
+"""
+/***************************************************************************
+ Plugin Utils
+                              -------------------
+        begin                : 28.4.2018
+        copyright            : (C) 2018 by OPENGIS.ch
+        email                : matthias@opengis.ch
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+"""
+
+import logging
+import os
+from logging import LogRecord
+from logging.handlers import TimedRotatingFileHandler
+
+from qgis.PyQt.QtCore import (
+    QDir,
+    QFileInfo,
+    QObject,
+    QSettings,
+    QStandardPaths,
+    QUrl,
+    pyqtSignal,
+)
+from qgis.PyQt.QtGui import QColor, QDesktopServices, QIcon
+from qgis.PyQt.uic import loadUiType
+
+logger = logging.getLogger("oqtopus")
+
+
+class PluginUtils:
+
+    PLUGIN_NAME = "Oqtopus"
+
+    logsDirectory = ""
+
+    COLOR_GREEN = QColor(12, 167, 137)
+    COLOR_WARNING = QColor(255, 165, 0)
+
+    @staticmethod
+    def plugin_root_path():
+        """
+        Returns the root path of the plugin
+        """
+        return os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir))
+
+    @staticmethod
+    def plugin_temp_path():
+        plugin_basename = PluginUtils.plugin_root_path().split(os.sep)[-1]
+
+        plugin_temp_dir = os.path.join(
+            QStandardPaths.writableLocation(QStandardPaths.StandardLocation.TempLocation),
+            plugin_basename,
+        )
+        if not os.path.exists(plugin_temp_dir):
+            os.makedirs(plugin_temp_dir)
+
+        return plugin_temp_dir
+
+    @staticmethod
+    def get_plugin_icon_path(icon_filename):
+        return os.path.join(PluginUtils.plugin_root_path(), "icons", icon_filename)
+
+    @staticmethod
+    def get_plugin_icon(icon_filename):
+        return QIcon(PluginUtils.get_plugin_icon_path(icon_filename=icon_filename))
+
+    @staticmethod
+    def get_ui_class(ui_file):
+        """Get UI Python class from .ui file.
+           Can be filename.ui or subdirectory/filename.ui
+        :param ui_file: The file of the ui in svir.ui
+        :type ui_file: str
+        """
+        os.path.sep.join(ui_file.split("/"))
+        ui_file_path = os.path.abspath(os.path.join(PluginUtils.plugin_root_path(), "ui", ui_file))
+        return loadUiType(ui_file_path)[0]
+
+    @staticmethod
+    def get_metadata_file_path():
+        return os.path.join(PluginUtils.plugin_root_path(), "metadata.txt")
+
+    @staticmethod
+    def get_plugin_version():
+        ini_text = QSettings(PluginUtils.get_metadata_file_path(), QSettings.Format.IniFormat)
+        return ini_text.value("version")
+
+    @staticmethod
+    def init_logger():
+        PluginUtils.logsDirectory = f"{PluginUtils.plugin_root_path()}/logs"
+
+        directory = QDir(PluginUtils.logsDirectory)
+        if not directory.exists():
+            directory.mkpath(PluginUtils.logsDirectory)
+
+        if directory.exists():
+            logfile = QFileInfo(directory, "Oqtopus.log")
+
+            # Handler for files rotation, create one log per day
+            rotationHandler = TimedRotatingFileHandler(
+                logfile.filePath(), when="midnight", backupCount=10
+            )
+
+            # Configure logging
+            logging.basicConfig(
+                level=logging.DEBUG,
+                format="%(asctime)s %(levelname)-7s %(message)s",
+                handlers=[rotationHandler],
+            )
+        else:
+            logger.error(f"Can't create log files directory '{PluginUtils.logsDirectory}'.")
+
+    @staticmethod
+    def open_logs_folder():
+        print(f"Opening logs folder {PluginUtils.logsDirectory}")
+        QDesktopServices.openUrl(QUrl.fromLocalFile(PluginUtils.logsDirectory))
+
+    @staticmethod
+    def open_log_file():
+        log_file_path = os.path.join(PluginUtils.logsDirectory, "Oqtopus.log")
+        if os.path.exists(log_file_path):
+            QDesktopServices.openUrl(QUrl.fromLocalFile(log_file_path))
+        else:
+            logger.error(f"Log file '{log_file_path}' does not exist.")
+
+    @staticmethod
+    def get_github_token():
+        settings = QSettings()
+        return settings.value("oqtopus/github_token", type=str)
+
+    @staticmethod
+    def set_github_token(token: str):
+        settings = QSettings()
+        settings.setValue("oqtopus/github_token", token)
+
+    @staticmethod
+    def get_github_headers():
+        token = PluginUtils.get_github_token()
+        headers = {}
+        if token:
+            headers["Authorization"] = f"token {token}"
+        return headers
+
+
+class LoggingBridge(logging.Handler, QObject):
+
+    loggedLine = pyqtSignal(LogRecord, str)
+
+    def __init__(self, level=logging.NOTSET, excluded_modules=[]):
+        QObject.__init__(self)
+        logging.Handler.__init__(self, level)
+
+        self.formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(name)s - %(message)s")
+
+        self.excluded_modules = excluded_modules
+
+    def filter(self, record):
+        return record.name not in self.excluded_modules
+
+    def emit(self, record):
+        log_entry = self.format(record)
+        print(log_entry)
+        self.loggedLine.emit(record, log_entry)