ibridgesgui 0.2.0__py3-none-any.whl

ibridgesgui/login.py

@@ -0,0 +1,101 @@
+"""Pop up Widget for Login."""
+
+import logging
+import sys
+from pathlib import Path
+
+from ibridges import Session
+from ibridges.session import LoginError, PasswordError
+from PyQt6.QtWidgets import QDialog, QLineEdit
+from PyQt6.uic import loadUi
+
+from ibridgesgui.config import get_last_ienv_path, set_last_ienv_path
+from ibridgesgui.gui_utils import UI_FILE_DIR
+from ibridgesgui.ui_files.irodsLogin import Ui_irodsLogin
+
+
+class Login(QDialog, Ui_irodsLogin):
+    """Definition and initialization of the iRODS login window."""
+
+    def __init__(self, session_dict, app_name):
+        """Initialise tab."""
+        super().__init__()
+        if getattr(sys, "frozen", False):
+            super().setupUi(self)
+        else:
+            loadUi(UI_FILE_DIR / "irodsLogin.ui", self)
+
+        self.logger = logging.getLogger(app_name)
+        self.irods_config_dir = Path("~", ".irods").expanduser()
+
+        self.session_dict = session_dict
+        self._init_envbox()
+        self.cached_pw = self._init_password()
+        self._load_gui()
+        self.setWindowTitle("Connect to iRODS server")
+
+    def _load_gui(self):
+        self.connect_button.clicked.connect(self.login_function)
+        self.cancel_button.clicked.connect(self.close)
+        self.password_field.setEchoMode(QLineEdit.EchoMode.Password)
+
+    def _init_envbox(self):
+        env_jsons = [path.name for path in self.irods_config_dir.glob("irods_environment*json")]
+        if len(env_jsons) == 0:
+            self.envError.setText(
+                f"ERROR: no irods_environment*json files found in {self.irods_config_dir}"
+            )
+
+        self.envbox.clear()
+        self.envbox.addItems(env_jsons)
+        last_env = get_last_ienv_path()
+        if last_env is not None and last_env in env_jsons:
+            self.envbox.setCurrentIndex(env_jsons.index(last_env))
+        else:
+            self.envbox.setCurrentIndex(0)
+
+    def _init_password(self):
+        # Check if there is a cached password
+        passwd_file = self.irods_config_dir.joinpath(".irodsA")
+        if passwd_file.is_file():
+            self.password_field.setText("***********")
+            return True
+        return False
+
+    def close(self):
+        """Abort login."""
+        self.done(0)
+
+    def login_function(self):
+        """Connect to iRODS server with gathered info."""
+        self.error_label.clear()
+        env_file = self.irods_config_dir.joinpath(self.envbox.currentText())
+        try:
+            if self.cached_pw is True and self.password_field.text() == "***********":
+                self.logger.debug("Login with %s and cached password.", env_file)
+                session = Session(irods_env=env_file)
+            else:
+                session = Session(irods_env=env_file, password=self.password_field.text())
+                self.logger.debug("Login with %s and password from prompt.", env_file)
+            self.session_dict["session"] = session
+            self.logger.info(
+                "Logged in as %s to %s; working coll %s",
+                session.username,
+                session.host,
+                session.home,
+            )
+            session.write_pam_password()
+            set_last_ienv_path(env_file.name)
+            self.close()
+        except LoginError:
+            self.error_label.setText("irods_environment.json not setup correctly.")
+        except PasswordError:
+            self.error_label.setText("Wrong password!")
+        except ConnectionError:
+            self.error_label.setText(
+                "Cannot connect to server. Check Internet, host name and port."
+            )
+        except Exception as err:
+            log_path = Path("~/.ibridges")
+            self.logger.exception("Failed to login: %s", repr(err))
+            self.error_label.setText(f"Login failed, consult the log file(s) in {log_path}")

ibridgesgui/popup_widgets.py

@@ -0,0 +1,237 @@
+"""Pop-up widget definitions."""
+
+import json
+import os
+import sys
+
+import irods
+from ibridges import IrodsPath
+from PyQt6 import QtCore
+from PyQt6.QtWidgets import QDialog, QFileDialog
+from PyQt6.uic import loadUi
+
+from ibridgesgui.config import _read_json, check_irods_config, save_irods_config
+from ibridgesgui.gui_utils import UI_FILE_DIR, populate_textfield
+from ibridgesgui.ui_files.configCheck import Ui_configCheck
+from ibridgesgui.ui_files.createCollection import Ui_createCollection
+from ibridgesgui.ui_files.renameItem import Ui_renameItem
+
+
+class CreateCollection(QDialog, Ui_createCollection):
+    """Popup window to create a new collection."""
+
+    def __init__(self, parent, logger):
+        """Initialise window."""
+        super().__init__()
+        if getattr(sys, "frozen", False):
+            super().setupUi(self)
+        else:
+            loadUi(UI_FILE_DIR / "createCollection.ui", self)
+
+        self.logger = logger
+        self.setWindowTitle("Create iRODS collection")
+        self.setWindowFlags(QtCore.Qt.WindowType.WindowStaysOnTopHint)
+        self.parent = parent
+        self.label.setText(str(self.parent) + "/")
+        self.buttonBox.accepted.connect(self.accept)
+
+    def accept(self):
+        """Create new collection."""
+        if self.coll_path_input.text() != "":
+            new_coll_path = IrodsPath(self.parent.session, self.parent, self.coll_path_input.text())
+            if new_coll_path.exists():
+                self.error_label.setText(f"{new_coll_path} already exists.")
+            else:
+                try:
+                    IrodsPath.create_collection(new_coll_path.session, new_coll_path)
+                    self.logger.info(f"Created collection {new_coll_path}")
+                    self.done(0)
+                except irods.exception.CAT_NO_ACCESS_PERMISSION:
+                    self.error_label.setText(
+                        f"No access rights to {new_coll_path.parent}."
+                        + f" Cannot create {self.coll_path_input.text()}."
+                    )
+                except Exception as err:
+                    self.logger.exception(f"Could not create {new_coll_path}: {err}")
+                    self.error_label.setText(f"Could not create {new_coll_path}, consult the logs.")
+
+
+class CreateDirectory(QDialog, Ui_createCollection):
+    """Popup window to create a new directory."""
+
+    def __init__(self, parent):
+        """Initialise window."""
+        super().__init__()
+        if getattr(sys, "frozen", False):
+            super().setupUi(self)
+        else:
+            loadUi(UI_FILE_DIR / "createCollection.ui", self)
+        self.setWindowTitle("Create Directory")
+        self.setWindowFlags(QtCore.Qt.WindowType.WindowStaysOnTopHint)
+        self.parent = parent
+        self.label.setText(self.parent + os.sep)
+        self.buttonBox.accepted.connect(self.accept)
+
+    def accept(self):
+        """Create folder."""
+        if self.coll_path_input.text() != "":
+            new_dir_path = self.parent + os.sep + self.coll_path_input.text()
+            try:
+                os.makedirs(new_dir_path)
+                self.done(1)
+            except Exception as error:
+                if hasattr(error, "message"):
+                    self.error_label.setText(error.message)
+                else:
+                    self.error_label.setText("ERROR: insufficient rights.")
+
+
+class Rename(QDialog, Ui_renameItem):
+    """Popup window to rename and move a collection or data object."""
+
+    def __init__(self, irods_path: IrodsPath, logger):
+        """Initialise window."""
+        super().__init__()
+        if getattr(sys, "frozen", False):
+            super().setupUi(self)
+        else:
+            loadUi(UI_FILE_DIR / "renameItem.ui", self)
+
+        self.logger = logger
+        self.setWindowTitle("Create iRODS collection")
+        self.setWindowFlags(QtCore.Qt.WindowType.WindowStaysOnTopHint)
+        self.irods_path = irods_path
+        self.item_path_label.setText(str(irods_path))
+        self.item_path_input.setText(str(irods_path))
+        self.buttonBox.accepted.connect(self.accept)
+
+    def accept(self):
+        """Create new collection."""
+        if self.item_path_input.text() != "":
+            new_path = IrodsPath(self.irods_path.session, self.item_path_input.text())
+            if new_path.exists():
+                self.error_label.setText(f"{new_path} already exists.")
+            else:
+                try:
+                    new_irods_path = self.irods_path.rename(new_path)
+                    self.logger.info(f"Rename/Move {self.irods_path} --> {new_irods_path}")
+                    self.done(0)
+                except irods.exception.CAT_NO_ACCESS_PERMISSION:
+                    self.error_label.setText(f"No access rights to {new_path}.")
+                except Exception as err:
+                    self.logger.exception(f"Could not create {new_path}: {err}")
+                    self.error_label.setText(f"Could not create {new_path}, consult the logs.")
+
+
+class CheckConfig(QDialog, Ui_configCheck):
+    """Popup window to edit, create and check an environment.json."""
+
+    def __init__(self, logger, env_path):
+        """Initialise window."""
+        super().__init__()
+        if getattr(sys, "frozen", False):
+            super().setupUi(self)
+        else:
+            loadUi(UI_FILE_DIR / "configCheck.ui", self)
+
+        self.logger = logger
+        self.env_path = env_path
+        self.setWindowTitle("Create, edit and inspect iRODS environment")
+        self._init_env_box()
+
+        self.envbox.activated.connect(self.load_env)
+        self.new_button.clicked.connect(self.create_env)
+        self.check_button.clicked.connect(self.check_env)
+        self.save_button.clicked.connect(self.save_env)
+        self.save_as_button.clicked.connect(self.save_env_as)
+        self.close_button.clicked.connect(self.close)
+
+    def _init_env_box(self):
+        self.envbox.clear()
+        env_jsons = [""] + [path.name for path in self.env_path.glob("irods_environment*json")]
+        if len(env_jsons) != 0:
+            self.envbox.addItems(env_jsons)
+            self.envbox.setCurrentIndex(0)
+
+    def load_env(self):
+        """Load json into text field."""
+        self.error_label.clear()
+        env_file = self.env_path.joinpath(self.envbox.currentText())
+        try:
+            content = json.dumps(
+                _read_json(env_file), sort_keys=True, indent=4, separators=(",", ": ")
+            )
+            populate_textfield(self.env_field, content)
+        except IsADirectoryError:
+            self.error_label.setText("Choose and environment or create a new one.")
+        except FileNotFoundError:
+            self.error_label.setText(f"File does not exist {env_file}")
+        except Exception as err:
+            self.error_label.setText(f"{repr(err)}")
+
+    def create_env(self):
+        """Load standard environment into text field."""
+        self.error_label.clear()
+        self.envbox.setCurrentIndex(0)
+        env = {
+            "irods_host": "<THE SERVER NAME OR IP ADDRESS>",
+            "irods_port": 1247,
+            "irods_home": "<A DEFAULT LOCATION ON THE IRODS SERVER AS YOUR HOME>",
+            "irods_default_resource": "<A DEFAULT IRODS RESOURCE NAME>",
+            "irods_user_name": "<YOUR IRODS USERNAME>",
+            "irods_zone_name": "<THE IRODS ZONE NAME>",
+            "irods_authentication_scheme": "pam",
+            "irods_encryption_algorithm": "AES-256-CBC",
+            "irods_encryption_key_size": 32,
+            "irods_encryption_num_hash_rounds": 16,
+            "irods_encryption_salt_size": 8,
+            "irods_client_server_policy": "CS_NEG_REQUIRE",
+            "irods_client_server_negotiation": "request_server_negotiation",
+        }
+        populate_textfield(
+            self.env_field, json.dumps(env, sort_keys=True, indent=4, separators=(",", ": "))
+        )
+
+    def check_env(self):
+        """Check formatting, parameters and connectivity of information in text field."""
+        self.error_label.clear()
+        try:
+            msg = check_irods_config(json.loads(self.env_field.toPlainText()))
+        except json.decoder.JSONDecodeError as err:
+            msg = f"JSON decoding error: {err.msg} at position {err.pos}."
+        self.error_label.setText(msg)
+
+    def save_env(self):
+        """Overwrite file from combobox with information from text field."""
+        self.error_label.clear()
+        env_file = self.env_path.joinpath(self.envbox.currentText())
+        if env_file.is_file():
+            try:
+                save_irods_config(env_file, json.loads(self.env_field.toPlainText()))
+                self.error_label.setText(f"Configuration saved  as {env_file}")
+            except json.decoder.JSONDecodeError:
+                self.error_label.setText(
+                    "Incorrectly formatted. Click 'Check' for more information."
+                )
+        else:
+            self.error_label.setText("Choose 'Save as' to save")
+
+    def save_env_as(self):
+        """Choose file to save text field as json."""
+        self.error_label.clear()
+        dialog = QFileDialog(self)
+        dialog.setFileMode(QFileDialog.FileMode.AnyFile)
+        dialog.setNameFilter("(*.json)")
+        create_file = QFileDialog.getSaveFileName(
+            self, "Save as File", str(self.env_path), "(*.json)"
+        )
+        if create_file[0] != "":
+            try:
+                save_irods_config(create_file[0], json.loads(self.env_field.toPlainText()))
+                self.error_label.setText(f"Configuration saved  as {create_file[0]}")
+            except json.decoder.JSONDecodeError:
+                self.error_label.setText(
+                    "Incorrectly formatted. Click 'Check' for more information."
+                )
+            except TypeError:
+                self.error_label.setText("File type needs to be .json")

ibridgesgui/search.py

@@ -0,0 +1,285 @@
+"""Search tab."""
+
+import logging
+import sys
+from pathlib import Path
+
+import PyQt6.uic
+from ibridges import IrodsPath
+from PyQt6 import QtCore, QtGui, QtWidgets
+from PyQt6.QtWidgets import QMessageBox
+
+from ibridgesgui.config import get_last_ienv_path, is_session_from_config
+from ibridgesgui.gui_utils import UI_FILE_DIR, combine_diffs, populate_table
+from ibridgesgui.threads import SearchThread, TransferDataThread
+from ibridgesgui.ui_files.tabSearch import Ui_tabSearch
+
+
+class Search(PyQt6.QtWidgets.QWidget, Ui_tabSearch):
+    """Search view."""
+
+    def __init__(self, session, app_name, browser):
+        """Initialize an iRODS search view.
+
+        This tab is linked to the browser tab. When double-clicking one of
+        the results the path will be loaded into the browser of the browser tab.
+
+        Parameters
+        ----------
+        session : ibridges.Session
+            The iRODS session object
+        app_name : str
+            The name of the app and corresponding logger
+        browser : PyQt6.QtWidgets.QWidget
+            The browser widget
+
+        """
+        super().__init__()
+        if getattr(sys, "frozen", False):
+            super().setupUi(self)
+        else:
+            PyQt6.uic.loadUi(UI_FILE_DIR / "tabSearch.ui", self)
+
+        self.logger = logging.getLogger(app_name)
+        self.session = session
+        self.browser = browser
+        self.search_thread = None
+        self.download_thread = None
+
+        self.hide_result_elements()
+        self.search_button.clicked.connect(self.search)
+        self.clear_button.clicked.connect(self.hide_result_elements)
+        self.download_button.clicked.connect(self.download)
+
+        # group textfields for gathering key, value, unit
+        self.keys = [self.key1, self.key2, self.key3, self.key4]
+        self.vals = [self.val1, self.val2, self.val3, self.val4]
+
+        self.search_table.doubleClicked.connect(self.send_to_browser)
+
+    def hide_result_elements(self):
+        """Hide the GUI elemnts that show and manipulate search results."""
+        self.error_label.clear()
+        self.search_table.hide()
+        self.download_button.hide()
+        self.clear_button.hide()
+        self.info_label.hide()
+        self.search_table.setRowCount(0)
+
+    def show_result_elements(self):
+        """Show the GUI elemnts that show and manipulate search results."""
+        self.search_table.show()
+        self.download_button.show()
+        self.clear_button.show()
+        self.info_label.show()
+
+    def search(self):
+        """Validate search parameters and start search."""
+        self.hide_result_elements()
+        self.setCursor(QtGui.QCursor(QtCore.Qt.CursorShape.WaitCursor))
+        self.error_label.clear()
+
+        msg, key_vals, path, checksum = self._validate_search_params()
+        if msg is not None:
+            self.error_label.setText(msg)
+            self.setCursor(QtGui.QCursor(QtCore.Qt.CursorShape.ArrowCursor))
+            return
+
+        if key_vals is None and path is None and checksum is None:
+            self.error_label.setText("No search critera given.")
+            self.setCursor(QtGui.QCursor(QtCore.Qt.CursorShape.ArrowCursor))
+            return
+
+        self._start_search(key_vals, path, checksum)
+
+    def load_results(self, results):
+        """Load seach results into the table view."""
+        self.error_label.clear()
+        table_data = []  # (Path, Name, Size, Checksum, created, modified)
+        for result in results:
+            if "DATA_NAME" in result:
+                obj = IrodsPath(self.session, result["COLL_NAME"], result["DATA_NAME"]).dataobject
+
+                table_data.append(
+                    (
+                        "-d",
+                        obj.path,
+                        obj.size,
+                        obj.create_time.strftime("%d-%m-%Y"),
+                        obj.modify_time.strftime("%d-%m-%Y"),
+                    )
+                )
+            else:
+                coll = IrodsPath(self.session, result["COLL_NAME"]).collection
+                table_data.append(
+                    (
+                        "-C",
+                        coll.path,
+                        "",
+                        coll.create_time.strftime("%d-%m-%Y"),
+                        coll.modify_time.strftime("%d-%m-%Y"),
+                    )
+                )
+            populate_table(self.search_table, len(table_data), table_data)
+
+    def download(self):
+        """Determine iRODS paths, select destination and start download."""
+        self.setCursor(QtGui.QCursor(QtCore.Qt.CursorShape.WaitCursor))
+        self.error_label.clear()
+        irods_paths = self._retrieve_selected_paths()
+        if len(irods_paths) == 0:
+            self.error_label.setText("No data selected.")
+            self.setCursor(QtGui.QCursor(QtCore.Qt.CursorShape.ArrowCursor))
+            return
+        select_dir = Path(
+            QtWidgets.QFileDialog.getExistingDirectory(
+                self, "Select Directory", directory=str(Path("~").expanduser())
+            )
+        )
+        if str(select_dir) == "" or str(select_dir) == ".":
+            self.setCursor(QtGui.QCursor(QtCore.Qt.CursorShape.ArrowCursor))
+            return
+        info = f"Download to: {select_dir}\n"
+
+        data_exists = [(ipath, select_dir.joinpath(ipath.name).exists()) for ipath in irods_paths]
+        overwrite = False
+
+        if any(exists for _, exists in data_exists):
+            button_reply = QMessageBox.question(
+                self,
+                "Message Box",
+                info + f"Some data already exists in {select_dir}." + "\nOverwrite data?",
+            )
+        else:
+            button_reply = QMessageBox.question(self, "Message Box", info)
+
+        if button_reply == QMessageBox.StandardButton.Yes:
+            overwrite = True
+            self._start_download(irods_paths, select_dir, overwrite)
+        else:
+            self.setCursor(QtGui.QCursor(QtCore.Qt.CursorShape.ArrowCursor))
+            return
+
+    def send_to_browser(self):
+        """Set browser path_input to collection or parent of object."""
+        row = self.search_table.currentIndex().row()
+        irods_path = IrodsPath(self.session, self.search_table.item(row, 1).text())
+        if irods_path.collection_exists():
+            self.browser.path_input.setText(str(irods_path))
+            self.error_label.setText(f"Browser tab switched to {irods_path}")
+        else:
+            self.browser.path_input.setText(str(irods_path.parent))
+            self.error_label.setText(f"Browser tab switched to {irods_path.parent}")
+        self.browser.load_browser_table()
+
+    def _validate_search_params(self) -> tuple[str, dict, str, str]:
+        # All metadata values need a specific key
+        if any(key.text() == "" and val.text() != "" for key, val in zip(self.keys, self.vals)):
+            return "There are metadata values without keys. Stop search.", None, None, None
+        if all(key.text() == "" for key in self.keys):
+            key_vals = None
+        else:
+            # Replace empty values with the wild card, turn into search key_vals
+            key_vals = {
+                key.text(): "%" if val.text() == "" else val.text()
+                for key, val in zip(self.keys, self.vals)
+            }
+            del key_vals[""]
+
+        path = self.path_field.text() if self.path_field.text() != "" else None
+        checksum = self.checksum_field.text() if self.checksum_field.text() != "" else None
+        return None, key_vals, path, checksum
+
+    def _retrieve_selected_paths(self) -> list[IrodsPath]:
+        """Retrieve paths from all selected rows in search results table."""
+        irods_paths = []
+        rows = set(idx.row() for idx in self.search_table.selectedIndexes())
+        for row in rows:
+            irods_paths.append(IrodsPath(self.session, self.search_table.item(row, 1).text()))
+        return irods_paths
+
+    def _start_download(self, irods_paths, folder, overwrite):
+        self.download_button.setEnabled(False)
+        self.clear_button.setEnabled(False)
+        self.search_button.setEnabled(False)
+        # check if session comes from env file in ibridges config
+        if is_session_from_config(self.session):
+            env_path = Path("~").expanduser().joinpath(".irods", get_last_ienv_path())
+        else:
+            text = "No download possible: The ibridges config changed during the session."
+            text += " Please reset or restart the session."
+            self.error_label.setText(text)
+            return
+
+        # get diff dictionary
+        diffs = combine_diffs(self.session, irods_paths, folder)
+
+        self.error_label.setText(f"Downloading to {folder} ....")
+        try:
+            self.download_thread = TransferDataThread(
+                env_path, self.logger, diffs, overwrite=overwrite
+            )
+        except Exception:
+            self.error_label.setText(
+                "Could not instantiate a new session from{env_path}.Check configuration"
+            )
+            self.setCursor(QtGui.QCursor(QtCore.Qt.CursorShape.ArrowCursor))
+            return
+        self.download_thread.succeeded.connect(self._download_end)
+        self.download_thread.finished.connect(self._finish_download)
+        self.download_thread.current_progress.connect(self._download_status)
+        self.download_thread.start()
+
+    def _finish_download(self):
+        self.download_button.setEnabled(True)
+        self.clear_button.setEnabled(True)
+        self.search_button.setEnabled(True)
+        self.setCursor(QtGui.QCursor(QtCore.Qt.CursorShape.ArrowCursor))
+        del self.download_thread
+
+    def _download_status(self, state):
+        self.error_label.setText(state)
+
+    def _download_end(self, thread_output: dict):
+        if thread_output["error"] == "":
+            self.error_label.setText("Download finished.")
+        else:
+            self.error_label.setText("Errors occurred during download. Consult the logs.")
+        self.setCursor(QtGui.QCursor(QtCore.Qt.CursorShape.ArrowCursor))
+
+    def _start_search(self, key_vals, path, checksum):
+        self.search_button.setEnabled(False)
+        # check if session comes from env file in ibridges config
+        if is_session_from_config(self.session):
+            env_path = Path("~").expanduser().joinpath(".irods", get_last_ienv_path())
+        else:
+            text = "No search possible: The ibridges config changed during the session."
+            text += " Please reset or restart the session."
+            self.error_label.setText(text)
+            return
+        self.error_label.setText("Searching ...")
+        try:
+            self.search_thread = SearchThread(self.logger, env_path, path, checksum, key_vals)
+        except Exception:
+            self.error_label.setText(
+                "Could not instantiate a new session from{env_path}.Check configuration"
+            )
+            return
+        self.search_thread.succeeded.connect(self._fetch_results)
+        self.search_thread.finished.connect(self._finish_search)
+        self.search_thread.start()
+
+    def _finish_search(self):
+        self.search_button.setEnabled(True)
+        self.setCursor(QtGui.QCursor(QtCore.Qt.CursorShape.ArrowCursor))
+        del self.search_thread
+
+    def _fetch_results(self, therad_output: dict):
+        if "error" in therad_output:
+            self.error_label.setText(therad_output["error"])
+        elif len(therad_output["results"]) == 0:
+            self.error_label.setText("No objects or collections found.")
+        else:
+            self.show_result_elements()
+            self.load_results(therad_output["results"])
+        self.setCursor(QtGui.QCursor(QtCore.Qt.CursorShape.ArrowCursor))