oqtopus 0.1.14__py3-none-any.whl

oqtopus/__init__.py

@@ -0,0 +1,4 @@
+def classFactory(iface):
+    from .oqtopus_plugin import OqtopusPlugin
+
+    return OqtopusPlugin(iface)

oqtopus/core/module.py

@@ -0,0 +1,115 @@
+import json
+
+from qgis.PyQt.QtCore import QByteArray, QObject, QUrl, pyqtSignal
+from qgis.PyQt.QtNetwork import QNetworkAccessManager, QNetworkReply, QNetworkRequest
+
+from ..utils.plugin_utils import PluginUtils
+from .module_package import ModulePackage
+
+
+class Module(QObject):
+    signal_versionsLoaded = pyqtSignal(str)
+    signal_developmentVersionsLoaded = pyqtSignal(str)
+
+    def __init__(self, name: str, organisation: str, repository: str, parent=None):
+        super().__init__(parent)
+        self.name = name
+        self.organisation = organisation
+        self.repository = repository
+        self.versions = []
+        self.development_versions = []
+        self.latest_version = None
+        self.network_manager = QNetworkAccessManager(self)
+
+    def __repr__(self):
+        return f"Module(name={self.name}, organisation={self.organisation}, repository={self.repository})"
+
+    def start_load_versions(self):
+        url = QUrl(f"https://api.github.com/repos/{self.organisation}/{self.repository}/releases")
+        request = QNetworkRequest(url)
+        headers = PluginUtils.get_github_headers()
+        for key, value in headers.items():
+            request.setRawHeader(QByteArray(key.encode()), QByteArray(value.encode()))
+        reply = self.network_manager.get(request)
+        reply.finished.connect(lambda: self._on_versions_reply(reply))
+
+    def _on_versions_reply(self, reply):
+        if reply.error() != QNetworkReply.NetworkError.NoError:
+            self.signal_versionsLoaded.emit(reply.errorString())
+            reply.deleteLater()
+            return
+        try:
+            data = reply.readAll().data()
+            json_versions = json.loads(data.decode())
+            self.versions = []
+            self.latest_version = None
+            for json_version in json_versions:
+                module_package = ModulePackage(
+                    module=self,
+                    organisation=self.organisation,
+                    repository=self.repository,
+                    json_payload=json_version,
+                    type=ModulePackage.Type.RELEASE,
+                )
+                self.versions.append(module_package)
+
+                # Latest version -> most recent commit date for non prerelease
+                if module_package.prerelease is True:
+                    continue
+
+                if self.latest_version is None:
+                    self.latest_version = module_package
+                    continue
+
+                if module_package.created_at > self.latest_version.created_at:
+                    self.latest_version = module_package
+            self.signal_versionsLoaded.emit("")
+        except Exception as e:
+            self.signal_versionsLoaded.emit(str(e))
+        reply.deleteLater()
+
+    def start_load_development_versions(self):
+        self.development_versions = []
+
+        # Create version for the main branch
+        mainVersion = ModulePackage(
+            module=self,
+            organisation=self.organisation,
+            repository=self.repository,
+            json_payload="",
+            type=ModulePackage.Type.BRANCH,
+            name="main",
+            branch="main",
+        )
+        self.development_versions.append(mainVersion)
+
+        url = QUrl(f"https://api.github.com/repos/{self.organisation}/{self.repository}/pulls")
+        request = QNetworkRequest(url)
+        headers = PluginUtils.get_github_headers()
+        for key, value in headers.items():
+            request.setRawHeader(QByteArray(key.encode()), QByteArray(value.encode()))
+        reply = self.network_manager.get(request)
+        reply.finished.connect(lambda: self._on_development_versions_reply(reply))
+
+    def _on_development_versions_reply(self, reply):
+        if reply.error() != QNetworkReply.NetworkError.NoError:
+            self.signal_developmentVersionsLoaded.emit(reply.errorString())
+            reply.deleteLater()
+            return
+
+        try:
+            data = reply.readAll().data()
+            json_versions = json.loads(data.decode())
+            for json_version in json_versions:
+                module_package = ModulePackage(
+                    module=self,
+                    organisation=self.organisation,
+                    repository=self.repository,
+                    json_payload=json_version,
+                    type=ModulePackage.Type.PULL_REQUEST,
+                )
+                self.development_versions.append(module_package)
+            self.signal_developmentVersionsLoaded.emit("")
+        except Exception as e:
+            self.signal_developmentVersionsLoaded.emit(str(e))
+        reply.deleteLater()

oqtopus/core/module_asset.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+
+class ModuleAsset:
+    class Type(Enum):
+        PLUGIN = "oqtopus.plugin"
+        PROJECT = "oqtopus.project"
+
+    def __init__(
+        self, name: str, label: str, download_url: str, size: int, type: "ModuleAsset.Type" = None
+    ):
+        self.name = name
+        self.label = label
+        self.download_url = download_url
+        self.size = size
+        self.type = type

oqtopus/core/module_package.py

@@ -0,0 +1,118 @@
+import requests
+from qgis.PyQt.QtCore import QDateTime, Qt
+
+from ..utils.plugin_utils import PluginUtils
+from .module_asset import ModuleAsset
+
+
+class ModulePackage:
+
+    # enum for package type
+    class Type:
+        RELEASE = "release"
+        BRANCH = "branch"
+        PULL_REQUEST = "pull_request"
+        FROM_ZIP = "from_zip"
+
+    def __init__(
+        self,
+        module,
+        organisation,
+        repository,
+        json_payload: dict,
+        type=Type.RELEASE,
+        name=None,
+        branch=None,
+    ):
+        self.module = module
+        self.type = type
+        self.name = name
+        self.branch = branch
+        self.created_at = None
+        self.prerelease = False
+        self.html_url = None
+
+        self.asset_project = None
+        self.asset_plugin = None
+
+        if self.type == ModulePackage.Type.RELEASE:
+            self.__parse_release(json_payload)
+        elif self.type == ModulePackage.Type.BRANCH:
+            pass
+        elif self.type == ModulePackage.Type.PULL_REQUEST:
+            self.__parse_pull_request(json_payload)
+        elif self.type == ModulePackage.Type.FROM_ZIP:
+            return
+        else:
+            raise ValueError(f"Unknown type '{type}'")
+
+        type = "heads"
+        if self.type == ModulePackage.Type.RELEASE:
+            type = "tags"
+
+        self.download_url = (
+            f"https://github.com/{organisation}/{repository}/archive/refs/{type}/{self.branch}.zip"
+        )
+
+        self.zip_file = None
+        self.package_dir = None
+
+    def display_name(self):
+        if self.prerelease:
+            return f"{self.name} (prerelease)"
+
+        return self.name
+
+    def __parse_release(self, json_payload: dict):
+        if self.name is None:
+            self.name = json_payload["name"]
+
+        if self.name is None or self.name == "":
+            self.name = json_payload["tag_name"]
+
+        self.branch = self.name
+        self.created_at = QDateTime.fromString(json_payload["created_at"], Qt.DateFormat.ISODate)
+        self.prerelease = json_payload["prerelease"]
+        self.html_url = json_payload["html_url"]
+
+        self.__parse_release_assets(json_payload["assets_url"])
+
+    def __parse_release_assets(self, assets_url: str):
+
+        # Load assets
+        r = requests.get(assets_url, headers=PluginUtils.get_github_headers())
+
+        # Raise an exception in case of http errors
+        r.raise_for_status()
+
+        json_assets = r.json()
+        for json_asset in json_assets:
+            asset = ModuleAsset(
+                name=json_asset["name"],
+                label=json_asset["label"],
+                download_url=json_asset["browser_download_url"],
+                size=json_asset["size"],
+                type=None,
+            )
+
+            if asset.label == ModuleAsset.Type.PROJECT.value:
+                asset.type = ModuleAsset.Type.PROJECT
+                self.asset_project = asset
+                continue
+
+            if asset.label == ModuleAsset.Type.PLUGIN.value:
+                asset.type = ModuleAsset.Type.PLUGIN
+                self.asset_plugin = asset
+                continue
+
+            if self.asset_project and self.asset_plugin:
+                # We already have all assets we need
+                break
+
+    def __parse_pull_request(self, json_payload: dict):
+        if self.name is None:
+            self.name = f"#{json_payload['number']} {json_payload['title']}"
+        self.branch = json_payload["head"]["ref"]
+        self.created_at = QDateTime.fromString(json_payload["created_at"], Qt.DateFormat.ISODate)
+        self.prerelease = False
+        self.html_url = json_payload["html_url"]

oqtopus/core/modules_config.py

@@ -0,0 +1,11 @@
+from pydantic import BaseModel
+
+
+class ModuleConfig(BaseModel):
+    name: str
+    organisation: str
+    repository: str
+
+
+class ModulesConfig(BaseModel):
+    modules: list[ModuleConfig]

oqtopus/core/package_prepare_task.py

@@ -0,0 +1,148 @@
+import os
+import shutil
+import zipfile
+
+import requests
+from qgis.PyQt.QtCore import QThread, pyqtSignal
+
+from ..utils.plugin_utils import PluginUtils, logger
+
+
+class PackagePrepareTaskCanceled(Exception):
+    pass
+
+
+class PackagePrepareTask(QThread):
+    """
+    This class is responsible for preparing the package for the Oqtopus module management tool.
+    It inherits from QThread to run the preparation process in a separate thread.
+    """
+
+    signalPackagingProgress = pyqtSignal(float)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        self.module_package = None
+
+        self.__canceled = False
+        self.lastError = None
+
+    def startFromZip(self, zip_file: str):
+
+        self.module_package = None
+
+        self.__canceled = False
+        self.start()
+
+    def startFromModulePackage(self, module_package):
+        self.module_package = module_package
+
+        self.__canceled = False
+        self.start()
+
+    def cancel(self):
+        self.__canceled = True
+
+    def run(self):
+        """
+        The main method that runs when the thread starts.
+        """
+
+        try:
+            if self.module_package is None:
+                raise Exception(self.tr("No module version provided."))
+
+            self.__download_module_assets(self.module_package)
+            self.lastError = None
+
+        except Exception as e:
+            # Handle any exceptions that occur during processing
+            logger.critical(f"Package prepare task error: {e}")
+            self.lastError = e
+
+    def __download_module_assets(self, module_package):
+
+        # Download the source
+        zip_file = self.__download_module_asset(module_package.download_url, "source.zip")
+        module_package.zip_file = zip_file
+        package_dir = self.__extract_zip_file(zip_file)
+        module_package.package_dir = package_dir
+
+        # Download the release assets
+        self.__checkForCanceled()
+        if module_package.asset_project is not None:
+            zip_file = self.__download_module_asset(
+                module_package.asset_project.download_url,
+                module_package.asset_project.type.value + ".zip",
+            )
+            package_dir = self.__extract_zip_file(zip_file)
+            module_package.asset_project.package_dir = package_dir
+
+        self.__checkForCanceled()
+        if module_package.asset_plugin is not None:
+            zip_file = self.__download_module_asset(
+                module_package.asset_plugin.download_url,
+                module_package.asset_plugin.type.value + ".zip",
+            )
+            package_dir = self.__extract_zip_file(zip_file)
+            module_package.asset_plugin.package_dir = package_dir
+
+    def __download_module_asset(self, url: str, filename: str):
+
+        temp_dir = PluginUtils.plugin_temp_path()
+        destination_directory = os.path.join(temp_dir, "Downloads")
+        os.makedirs(destination_directory, exist_ok=True)
+
+        zip_file = os.path.join(destination_directory, filename)
+
+        # Streaming, so we can iterate over the response.
+        response = requests.get(url, allow_redirects=True, stream=True)
+
+        # Raise an exception in case of http errors
+        response.raise_for_status()
+
+        self.__checkForCanceled()
+
+        logger.info(f"Downloading from '{url}' to '{zip_file}'")
+        data_size = 0
+        with open(zip_file, "wb") as file:
+            next_emit_threshold = 10 * 1024 * 1024  # 10MB threshold
+            for data in response.iter_content(chunk_size=None):
+                file.write(data)
+
+                self.__checkForCanceled()
+
+                data_size += len(data)
+                if data_size >= next_emit_threshold:  # Emit signal when threshold is exceeded
+                    self.signalPackagingProgress.emit(data_size)
+                    next_emit_threshold += 10 * 1024 * 1024  # Update to the next threshold
+
+        return zip_file
+
+    def __extract_zip_file(self, zip_file):
+        temp_dir = PluginUtils.plugin_temp_path()
+
+        # Unzip the file to plugin temp dir
+        try:
+            with zipfile.ZipFile(zip_file, "r") as zip_ref:
+                # Find the top-level directory
+                zip_dirname = zip_ref.namelist()[0].split("/")[0]
+                package_dir = os.path.join(temp_dir, zip_dirname)
+
+                if os.path.exists(package_dir):
+                    shutil.rmtree(package_dir)
+
+                zip_ref.extractall(temp_dir)
+
+        except zipfile.BadZipFile:
+            raise Exception(self.tr(f"The selected file '{zip_file}' is not a valid zip archive."))
+
+        return package_dir
+
+    def __checkForCanceled(self):
+        """
+        Check if the task has been canceled.
+        """
+        if self.__canceled:
+            raise PackagePrepareTaskCanceled(self.tr("The task has been canceled."))

oqtopus/gui/about_dialog.py

@@ -0,0 +1,61 @@
+# -----------------------------------------------------------
+#
+# Profile
+# Copyright (C) 2012  Patrice Verchere
+# -----------------------------------------------------------
+#
+# licensed under the terms of GNU GPL 2
+#
+# 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.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, print to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# ---------------------------------------------------------------------
+
+
+from qgis.PyQt.QtCore import QSettings, Qt
+from qgis.PyQt.QtGui import QPixmap
+from qgis.PyQt.QtWidgets import QDialog
+
+from ..utils.plugin_utils import PluginUtils
+
+DIALOG_UI = PluginUtils.get_ui_class("about_dialog.ui")
+
+
+class AboutDialog(QDialog, DIALOG_UI):
+    def __init__(self, parent=None):
+        QDialog.__init__(self, parent)
+        self.setupUi(self)
+
+        metadata_file_path = PluginUtils.get_metadata_file_path()
+
+        ini_text = QSettings(metadata_file_path, QSettings.Format.IniFormat)
+        version = ini_text.value("version")
+        name = ini_text.value("name")
+        description = "".join(ini_text.value("description"))
+        about = " ".join(ini_text.value("about"))
+        qgisMinimumVersion = ini_text.value("qgisMinimumVersion")
+
+        self.setWindowTitle(f"{name} - {version}")
+        self.titleLabel.setText(self.windowTitle())
+        self.descriptionLabel.setText(description)
+        self.aboutLabel.setText(about)
+        self.qgisMinimumVersionLabel.setText(qgisMinimumVersion)
+
+        scaled_logo = QPixmap(PluginUtils.get_plugin_icon_path("oqtopus-logo.png")).scaled(
+            254,
+            254,
+            aspectRatioMode=Qt.AspectRatioMode.KeepAspectRatio,
+            transformMode=Qt.TransformationMode.SmoothTransformation,
+        )
+        self.iconLabel.setPixmap(scaled_logo)

oqtopus/gui/database_connection_widget.py

@@ -0,0 +1,154 @@
+import psycopg
+from pgserviceparser import conf_path as pgserviceparser_conf_path
+from pgserviceparser import service_config as pgserviceparser_service_config
+from pgserviceparser import service_names as pgserviceparser_service_names
+from qgis.PyQt.QtCore import pyqtSignal
+from qgis.PyQt.QtGui import QAction
+from qgis.PyQt.QtWidgets import QDialog, QMenu, QWidget
+
+from ..utils.plugin_utils import PluginUtils, logger
+from ..utils.qt_utils import CriticalMessageBox, QtUtils
+from .database_create_dialog import DatabaseCreateDialog
+from .database_duplicate_dialog import DatabaseDuplicateDialog
+
+DIALOG_UI = PluginUtils.get_ui_class("database_connection_widget.ui")
+
+
+class DatabaseConnectionWidget(QWidget, DIALOG_UI):
+
+    signal_connectionChanged = pyqtSignal()
+
+    def __init__(self, parent=None):
+        QWidget.__init__(self, parent)
+        self.setupUi(self)
+
+        self.db_database_label.setText(self.tr("No database"))
+        QtUtils.setForegroundColor(self.db_database_label, PluginUtils.COLOR_WARNING)
+        QtUtils.setFontItalic(self.db_database_label, True)
+
+        self.__loadDatabaseInformations()
+        self.db_services_comboBox.currentIndexChanged.connect(self.__serviceChanged)
+
+        db_operations_menu = QMenu(self.db_operations_toolButton)
+
+        actionCreateDb = QAction(self.tr("Create database"), db_operations_menu)
+        self.__actionDuplicateDb = QAction(self.tr("Duplicate database"), db_operations_menu)
+        actionReloadPgServices = QAction(self.tr("Reload PG Service config"), db_operations_menu)
+
+        actionCreateDb.triggered.connect(self.__createDatabaseClicked)
+        self.__actionDuplicateDb.triggered.connect(self.__duplicateDatabaseClicked)
+        actionReloadPgServices.triggered.connect(self.__loadDatabaseInformations)
+
+        db_operations_menu.addAction(actionCreateDb)
+        db_operations_menu.addAction(self.__actionDuplicateDb)
+        db_operations_menu.addAction(actionReloadPgServices)
+
+        self.db_operations_toolButton.setMenu(db_operations_menu)
+
+        self.__database_connection = None
+
+        try:
+            self.__serviceChanged()
+        except Exception:
+            # Silence errors during widget initialization
+            pass
+
+    def getConnection(self):
+        """
+        Returns the current database connection.
+        If no connection is established, returns None.
+        """
+        return self.__database_connection
+
+    def __loadDatabaseInformations(self):
+        pg_service_conf_path = pgserviceparser_conf_path()
+        self.db_servicesConfigFilePath_label.setText(
+            f"<a href='file://{pg_service_conf_path.resolve()}'>{pg_service_conf_path.as_posix()}</a>"
+        )
+
+        self.db_services_comboBox.clear()
+
+        try:
+            for service_name in pgserviceparser_service_names():
+                self.db_services_comboBox.addItem(service_name)
+        except Exception as exception:
+            CriticalMessageBox(
+                self.tr("Error"), self.tr("Can't load database services:"), exception, self
+            ).exec()
+            return
+
+    def __serviceChanged(self, index=None):
+        if self.db_services_comboBox.currentText() == "":
+            self.db_database_label.setText(self.tr("No database"))
+            QtUtils.setForegroundColor(self.db_database_label, PluginUtils.COLOR_WARNING)
+            QtUtils.setFontItalic(self.db_database_label, True)
+
+            self.__actionDuplicateDb.setDisabled(True)
+
+            self.__set_connection(None)
+            return
+
+        service_name = self.db_services_comboBox.currentText()
+        service_config = pgserviceparser_service_config(service_name)
+
+        service_database = service_config.get("dbname", None)
+
+        if service_database is None:
+            self.db_database_label.setText(self.tr("No database provided by the service"))
+            QtUtils.setForegroundColor(self.db_database_label, PluginUtils.COLOR_WARNING)
+            QtUtils.setFontItalic(self.db_database_label, True)
+
+            self.__actionDuplicateDb.setDisabled(True)
+            return
+
+        self.db_database_label.setText(service_database)
+        QtUtils.resetForegroundColor(self.db_database_label)
+        QtUtils.setFontItalic(self.db_database_label, False)
+
+        self.__actionDuplicateDb.setEnabled(True)
+
+        # Try connection
+        try:
+            database_connection = psycopg.connect(service=service_name)
+            self.__set_connection(database_connection)
+
+        except Exception as exception:
+            self.__set_connection(None)
+
+            self.db_moduleInfo_label.setText("Can't connect to service.")
+            QtUtils.setForegroundColor(self.db_moduleInfo_label, PluginUtils.COLOR_WARNING)
+            errorText = self.tr(f"Can't connect to service '{service_name}':\n{exception}.")
+            logger.error(errorText)
+            return
+
+        self.db_moduleInfo_label.setText("Connected.")
+        logger.info(f"Connected to service '{service_name}'.")
+        QtUtils.resetForegroundColor(self.db_moduleInfo_label)
+
+    def __createDatabaseClicked(self):
+        databaseCreateDialog = DatabaseCreateDialog(
+            selected_service=self.db_services_comboBox.currentText(), parent=self
+        )
+
+        if databaseCreateDialog.exec() == QDialog.DialogCode.Rejected:
+            return
+
+        self.__loadDatabaseInformations()
+
+        # Select the created service
+        created_service_name = databaseCreateDialog.created_service_name()
+        self.db_services_comboBox.setCurrentText(created_service_name)
+
+    def __duplicateDatabaseClicked(self):
+        databaseDuplicateDialog = DatabaseDuplicateDialog(
+            selected_service=self.db_services_comboBox.currentText(), parent=self
+        )
+        if databaseDuplicateDialog.exec() == QDialog.DialogCode.Rejected:
+            return
+
+    def __set_connection(self, connection):
+        """
+        Set the current database connection and emit the signal_connectionChanged signal.
+        """
+        self.__database_connection = connection
+        self.signal_connectionChanged.emit()