log filter

Author: domi4484

.github/workflows/plugin-package.yml

@@ -37,10 +37,6 @@ jobs:
       - name: Install qgis-plugin-ci
         run: pip install qgis-plugin-ci>=2.8.6
 
-      - name: 🌍 Push translations
-        if: ${{ github.event_name == 'push' }}
-        run: qgis-plugin-ci push-translation ${{ secrets.TX_TOKEN }}
-
       - name: Package PyPI Packages
         run: ./scripts/package-pip-packages.sh
 
@@ -50,7 +46,6 @@ jobs:
           qgis-plugin-ci -v package ${VERSION} \
             --allow-uncommitted-changes \
             --asset-path plugin/teksi_module_management_tool/libs \
-            # --transifex-token "${{ secrets.TX_TOKEN }}"
 
       - uses: actions/upload-artifact@v4
         with:

oqtopus/core/module_version.py

@@ -11,6 +11,7 @@ class Type:
         RELEASE = "release"
         BRANCH = "branch"
         PULL_REQUEST = "pull_request"
+        FROM_ZIP = "from_zip"
 
     def __init__(
         self,
@@ -39,6 +40,8 @@ def __init__(
             pass
         elif self.type == ModuleVersion.Type.PULL_REQUEST:
             self.__parse_pull_request(json_payload)
+        elif self.type == ModuleVersion.Type.FROM_ZIP:
+            return
         else:
             raise ValueError(f"Unknown type '{type}'")
 

oqtopus/core/package_prepare_task.py

@@ -57,10 +57,10 @@ def run(self):
         """
 
         try:
-            if self.module_version is not None:
-                self.__download_module_assets(self.module_version)
+            if self.module_version is None:
+                raise Exception(self.tr("No module version provided."))
 
-            self.__extract_zip_file(self.zip_file)
+            self.__download_module_assets(self.module_version)
 
         except Exception as e:
             # Handle any exceptions that occur during processing
@@ -69,27 +69,46 @@ def run(self):
 
     def __download_module_assets(self, module_version):
 
+        # Download the source
+        zip_file = self.__download_module_asset(module_version.download_url, "source.zip")
+        package_dir = self.__extract_zip_file(zip_file)
+        module_version.package_dir = package_dir
+
+        # Download the release assets
+        self.__checkForCanceled()
         if module_version.asset_datamodel is not None:
-            self.__download_module_asset(module_version.asset_datamodel)
+            zip_file = self.__download_module_asset(
+                module_version.asset_datamodel.download_url,
+                module_version.asset_datamodel.type.value + ".zip",
+            )
+            package_dir = self.__extract_zip_file(zip_file)
+            module_version.asset_datamodel.package_dir = package_dir
 
         self.__checkForCanceled()
         if module_version.asset_project is not None:
-            self.__download_module_asset(module_version.asset_project)
+            zip_file = self.__download_module_asset(
+                module_version.asset_project.download_url,
+                module_version.asset_project.type.value + ".zip",
+            )
+            package_dir = self.__extract_zip_file(zip_file)
+            module_version.asset_project.package_dir = package_dir
 
         self.__checkForCanceled()
         if module_version.asset_plugin is not None:
-            self.__download_module_asset(module_version.asset_plugin)
-
-    def __download_module_asset(self, module_asset):
+            zip_file = self.__download_module_asset(
+                module_version.asset_plugin.download_url,
+                module_version.asset_plugin.type.value + ".zip",
+            )
+            package_dir = self.__extract_zip_file(zip_file)
+            module_version.asset_plugin.package_dir = package_dir
 
-        url = module_asset.download_url
-        filename = module_asset.type.value + ".zip"
+    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)
 
-        self.zip_file = os.path.join(destination_directory, filename)
+        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)
@@ -99,9 +118,9 @@ def __download_module_asset(self, module_asset):
 
         self.__checkForCanceled()
 
-        logger.info(f"Downloading from '{url}' to '{self.zip_file}'")
+        logger.info(f"Downloading from '{url}' to '{zip_file}'")
         data_size = 0
-        with open(self.zip_file, "wb") as file:
+        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)
@@ -113,6 +132,8 @@ def __download_module_asset(self, module_asset):
                     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()
 
@@ -121,16 +142,18 @@ def __extract_zip_file(self, zip_file):
             with zipfile.ZipFile(zip_file, "r") as zip_ref:
                 # Find the top-level directory
                 zip_dirname = zip_ref.namelist()[0].split("/")[0]
-                self.package_dir = os.path.join(temp_dir, zip_dirname)
+                package_dir = os.path.join(temp_dir, zip_dirname)
 
-                if os.path.exists(self.package_dir):
-                    shutil.rmtree(self.package_dir)
+                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.

oqtopus/gui/main_dialog.py

@@ -25,6 +25,7 @@
 import logging
 import os
 import shutil
+import traceback
 
 import psycopg
 from qgis.PyQt.QtCore import Qt, QUrl
@@ -41,6 +42,7 @@
 )
 
 from ..core.module import Module
+from ..core.module_version import ModuleVersion
 from ..core.package_prepare_task import PackagePrepareTask
 from ..libs import pgserviceparser
 from ..libs.pum.config import PumConfig
@@ -56,7 +58,6 @@
 
 class MainDialog(QDialog, DIALOG_UI):
 
-    MODULE_VERSION_SPECIAL_LOAD_FROM_ZIP = "Load from ZIP"
     MODULE_VERSION_SPECIAL_LOAD_DEVELOPMENT = "Load development versions"
 
     COLOR_GREEN = QColor(12, 167, 137)
@@ -66,7 +67,9 @@ def __init__(self, modules_config, parent=None):
         QDialog.__init__(self, parent)
         self.setupUi(self)
 
-        self.loggingBridge = LoggingBridge()
+        self.loggingBridge = LoggingBridge(
+            level=logging.NOTSET, excluded_modules=["urllib3.connectionpool"]
+        )
         self.loggingBridge.loggedLine.connect(self.__logged_line)
         logging.getLogger().addHandler(self.loggingBridge)
 
@@ -78,7 +81,6 @@ def __init__(self, modules_config, parent=None):
 
         self.__database_connection = None
 
-        self.__package_dir = None
         self.__data_model_dir = None
         self.__pum_config = None
         self.__project_file = None
@@ -234,21 +236,42 @@ def __moduleChanged(self, index):
         logger.info(f"Loading versions for module '{self.__current_module.name}'...")
         QApplication.processEvents()
 
-        with OverrideCursor(Qt.WaitCursor):
-            if self.__current_module.versions == list():
-                self.__current_module.load_versions()
+        try:
+            with OverrideCursor(Qt.WaitCursor):
+                if self.__current_module.versions == list():
+                    self.__current_module.load_versions()
 
-            for module_version in self.__current_module.versions:
-                self.module_version_comboBox.addItem(module_version.display_name(), module_version)
+                for module_version in self.__current_module.versions:
+                    self.module_version_comboBox.addItem(
+                        module_version.display_name(), module_version
+                    )
 
-            if self.__current_module.latest_version is not None:
-                self.module_latestVersion_label.setText(
-                    f"Latest: {self.__current_module.latest_version.name}"
-                )
+                if self.__current_module.latest_version is not None:
+                    self.module_latestVersion_label.setText(
+                        f"Latest: {self.__current_module.latest_version.name}"
+                    )
+
+        except Exception as exception:
+            msg_box = QMessageBox(self)
+            msg_box.setIcon(QMessageBox.Critical)
+            msg_box.setWindowTitle(self.tr("Error"))
+            msg_box.setText(self.tr(f"Can't load module versions:\n{exception}"))
+            details = "".join(
+                traceback.format_exception(type(exception), exception, exception.__traceback__)
+            )
+            msg_box.setDetailedText(details)
+            msg_box.exec_()
+            return
 
         self.module_version_comboBox.insertSeparator(self.module_version_comboBox.count())
         self.module_version_comboBox.addItem(
-            self.tr("Load from ZIP file"), self.MODULE_VERSION_SPECIAL_LOAD_FROM_ZIP
+            self.tr("Load from ZIP file"),
+            ModuleVersion(
+                organisation=self.__current_module.organisation,
+                repository=self.__current_module.repository,
+                json_payload=None,
+                type=ModuleVersion.Type.FROM_ZIP,
+            ),
         )
 
         self.module_version_comboBox.insertSeparator(self.module_version_comboBox.count())
@@ -258,12 +281,6 @@ def __moduleChanged(self, index):
 
     def __moduleVersionChanged(self, index):
 
-        if self.module_version_comboBox.currentData() == self.MODULE_VERSION_SPECIAL_LOAD_FROM_ZIP:
-            self.module_zipPackage_groupBox.setVisible(True)
-            return
-        else:
-            self.module_zipPackage_groupBox.setVisible(False)
-
         if (
             self.module_version_comboBox.currentData()
             == self.MODULE_VERSION_SPECIAL_LOAD_DEVELOPMENT
@@ -275,7 +292,12 @@ def __moduleVersionChanged(self, index):
         if current_module_version is None:
             return
 
-        self.__package_dir = None
+        if current_module_version.type == current_module_version.Type.FROM_ZIP:
+            self.module_zippackage_groupBox.setVisible(True)
+            return
+        else:
+            self.module_zipPackage_groupBox.setVisible(False)
+
         self.__data_model_dir = None
         self.__pum_config = None
         self.__project_file = None
@@ -336,7 +358,6 @@ def __moduleBrowseZipClicked(self):
 
     def __loadModuleFromZip(self, filename):
 
-        self.__package_dir = None
         self.__data_model_dir = None
         self.__pum_config = None
         self.__project_file = None
@@ -352,27 +373,36 @@ def __packagePrepareTaskFinished(self):
 
         if self.__packagePrepareTask.lastError is not None:
             error_text = f"Can't load module package:\n{self.__packagePrepareTask.lastError}"
+            # Get the stack trace as a string
+            details = "".join(
+                traceback.format_exception(
+                    type(self.__packagePrepareTask.lastError),
+                    self.__packagePrepareTask.lastError,
+                    self.__packagePrepareTask.lastError.__traceback__,
+                )
+            )
+            msg_box = QMessageBox(self)
+            msg_box.setIcon(QMessageBox.Critical)
+            msg_box.setWindowTitle(self.tr("Error"))
+            msg_box.setText(self.tr(error_text))
+            msg_box.setDetailedText(details)
+            msg_box.exec_()
             self.module_information_label.setText(error_text)
             QtUtils.setForegroundColor(self.module_information_label, self.COLOR_WARNING)
-            QMessageBox.critical(
-                self,
-                self.tr("Error"),
-                self.tr(error_text),
-            )
             return
 
-        self.__package_dir = self.__packagePrepareTask.package_dir
-        logger.info(f"Package loaded into '{self.__package_dir}'")
-        self.module_information_label.setText(self.__package_dir)
+        package_dir = self.module_version_comboBox.currentData().package_dir
+        logger.info(f"Package loaded into '{package_dir}'")
+        self.module_information_label.setText(package_dir)
         QtUtils.resetForegroundColor(self.module_information_label)
 
         self.__packagePrepareGetPUMConfig()
 
         self.__packagePrepareGetProjectFilename()
 
     def __packagePrepareGetPUMConfig(self):
-
-        self.__data_model_dir = os.path.join(self.__package_dir, "datamodel")
+        package_dir = self.module_version_comboBox.currentData().package_dir
+        self.__data_model_dir = os.path.join(package_dir, "datamodel")
         pumConfigFilename = os.path.join(self.__data_model_dir, ".pum.yaml")
         if not os.path.exists(pumConfigFilename):
             QMessageBox.critical(
@@ -416,7 +446,8 @@ def __packagePrepareGetPUMConfig(self):
 
     def __packagePrepareGetProjectFilename(self):
         # Search for QGIS project file in self.__package_dir
-        project_file_dir = os.path.join(self.__package_dir, "project")
+        package_dir = self.module_version_comboBox.currentData().asset_project.package_dir
+        project_file_dir = os.path.join(package_dir, "project")
 
         # Check if the directory exists
         if not os.path.exists(project_file_dir):
@@ -678,25 +709,34 @@ def __projectInstallClicked(self):
             )
             return
 
-        current_module_version = self.module_version_comboBox.currentData()
-        if current_module_version is None:
+        if self.module_version_comboBox.currentData() is None:
             QMessageBox.warning(
                 self,
                 self.tr("Error"),
                 self.tr("Please select a module version first."),
             )
             return
 
-        if self.__package_dir is None:
+        asset_project = self.module_version_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:
             QMessageBox.critical(
                 self,
                 self.tr("Error"),
                 self.tr("No valid package directory available."),
             )
             return
 
-        # Search for QGIS project file in self.__package_dir
-        project_file_dir = os.path.join(self.__package_dir, "project")
+        # 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):

oqtopus/utils/plugin_utils.py

@@ -133,12 +133,17 @@ class LoggingBridge(logging.Handler, QObject):
 
     loggedLine = pyqtSignal(LogRecord, str)
 
-    def __init__(self, level=logging.NOTSET):
+    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)
         self.loggedLine.emit(record, log_entry)