ibridgesgui 0.2.0__py3-none-any.whl

ibridgesgui/config.py

@@ -0,0 +1,250 @@
+"""Setting up logger and configuration files."""
+
+import datetime
+import json
+import logging
+import logging.handlers
+import sys
+from json import JSONDecodeError
+from pathlib import Path
+from typing import Union
+
+from ibridges.session import Session
+from irods.connection import PlainTextPAMPasswordError
+from irods.exception import (
+    CAT_INVALID_AUTHENTICATION,
+    CAT_INVALID_USER,
+    PAM_AUTH_PASSWORD_FAILED,
+    NetworkException,
+)
+from irods.session import iRODSSession
+
+LOG_LEVEL = {
+    "fulldebug": logging.DEBUG - 5,
+    "debug": logging.DEBUG,
+    "info": logging.INFO,
+    "warn": logging.WARNING,
+    "error": logging.ERROR,
+    "critical": logging.CRITICAL,
+}
+
+CONFIG_DIR = Path("~", ".ibridges").expanduser()
+CONFIG_FILE = CONFIG_DIR.joinpath("ibridges_gui.json")
+
+
+def ensure_log_config_location():
+    """Ensure the location for logs and config files."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+
+# logging functions
+def init_logger(app_name: str, log_level: str) -> logging.Logger:
+    """Create a logger for the app.
+
+    app_name : str
+        Name of the app, will be used as file name
+    log_level : str
+        String that will be mapped to python's log levels, default is info
+    """
+    logger = logging.getLogger(app_name)
+    logfile = CONFIG_DIR.joinpath(f"{app_name}.log")
+
+    # Direct logging to logfile
+    formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+    file_handler = logging.handlers.RotatingFileHandler(logfile, "a", 100000, 1)
+    file_handler.setFormatter(formatter)
+    logger.addHandler(file_handler)
+    logger.setLevel(LOG_LEVEL.get(log_level, LOG_LEVEL["info"]))
+
+    # Logger greeting when app is started
+    with open(logfile, "a", encoding="utf-8") as logfd:
+        logfd.write("\n\n")
+        underscores = f"{'_' * 50}\n"
+        logfd.write(underscores * 2)
+        logfd.write(f"\t Starting iBridges-GUI \n\t{datetime.datetime.now().isoformat()}\n")
+        logfd.write(underscores * 2)
+
+    return logger
+
+
+# ibridges config functions
+def get_last_ienv_path() -> Union[None, str]:
+    """Retrieve last used environment path from the config file."""
+    config = _get_config()
+    if config is not None:
+        return config.get("gui_last_env")
+    return None
+
+
+def set_last_ienv_path(ienv_path: Path):
+    """Save the last used environment path to the config file.
+
+    ienv_path : Path
+        Path to last environment
+    """
+    config = _get_config()
+    if config is not None:
+        config["gui_last_env"] = ienv_path
+    else:
+        config = {"gui_last_env": ienv_path}
+    _save_config(config)
+
+
+def get_log_level() -> Union[None, str]:
+    """Retrieve log level from config."""
+    config = _get_config()
+    if config is not None:
+        return config.get("log_level")
+    return None
+
+
+def set_log_level(level: str):
+    """Save log level to config."""
+    config = _get_config()
+    if config is not None:
+        config["log_level"] = level
+    else:
+        config = {"log_level": level}
+    _save_config(config)
+
+
+def _save_config(conf: dict):
+    ensure_log_config_location()
+    _write_json(CONFIG_FILE, conf)
+
+
+def _get_config() -> Union[None, dict]:
+    try:
+        return _read_json(CONFIG_FILE)
+    except FileNotFoundError:
+        return None
+    except JSONDecodeError as err:
+        # empty file
+        if err.msg == "Expecting value":
+            return None
+        print(f"CANNOT START APP: {CONFIG_FILE} incorrectly formatted.")
+        sys.exit(1)
+
+
+# irods config functions
+
+
+def is_session_from_config(session: Session) -> Union[Session, None]:
+    """Create a new session from the given session.
+
+    For the QThreads we need an own session to avoid hickups.
+    We will verify that the given session was instantiated by the
+    parameters saved in the ibridges configuration.
+    """
+    ienv_path = Path("~").expanduser().joinpath(".irods", get_last_ienv_path())
+    try:
+        env = _read_json(ienv_path)
+    except Exception:
+        return False
+
+    if (
+        session.host == env.get("irods_host", -1)
+        and session.port == env.get("irods_port", -1)
+        and session.zone == env.get("irods_zone_name", -1)
+        and session.username == env.get("irods_user_name")
+        and session.home == env.get("irods_home", -1)
+        and session.default_resc == env.get("irods_default_resource", -1)
+    ):
+        return True
+    return False
+
+
+def check_irods_config(ienv: Union[Path, dict]) -> str:
+    """Check whether an iRODS configuration file is correct.
+
+    Parameters
+    ----------
+    ienv : Path or dict
+        Path to the irods_environment.json or the dictionary conatining the json.
+
+    Returns
+    -------
+    str :
+        Error message why login with the settings would fail.
+        "All checks passed successfully" in case all seems to be fine.
+
+    """
+    if isinstance(ienv, Path):
+        try:
+            env = _read_json(ienv)
+        except FileNotFoundError:
+            return f"{ienv} not found."
+        except JSONDecodeError as err:
+            print(repr(err))
+            return f"{ienv} not well formatted.\n {err.msg} at position {err.pos}."
+    else:
+        env = ienv
+    # check host and port and connectivity
+    if "irods_host" not in env:
+        return '"irods_host" is missing in environment.'
+    if "irods_port" not in env:
+        return '"irods_port" is missing in environment.'
+    if "irods_home" not in env:
+        return 'Please set an "irods_home".'
+    if "irods_default_resource" not in env:
+        return 'Please set an "irods_default_resource".'
+    if not isinstance(env["irods_port"], int):
+        return '"irods_port" needs to be an integer, remove quotes.'
+    if not Session.network_check(env["irods_host"], env["irods_port"]):
+        return f'No connection: Network might be down or\n \
+                server name {env["irods_host"]} is incorrect or\n \
+                port {env["irods_port"]} is incorrect.'
+    # check authentication scheme
+    try:
+        sess = iRODSSession(password="bogus", **env)
+        _ = sess.server_version
+    except TypeError as err:
+        return repr(err)
+    except NetworkException as err:
+        return repr(err)
+    except AttributeError as err:
+        return repr(err)
+
+    except PlainTextPAMPasswordError:
+        return (
+            'Value of "irods_client_server_negotiation" needs to be'
+            + ' "request_server_negotiation".'
+        )
+
+    except CAT_INVALID_AUTHENTICATION:
+        return 'Wrong "irods_authentication_scheme".'
+    except ValueError as err:
+        if "scheme" in err.args[0]:
+            return 'Value of "irods_authentication_scheme" not recognised.'
+        return f"{err.args}"
+
+    # password incorrect but rest is fine
+    except (CAT_INVALID_USER, PAM_AUTH_PASSWORD_FAILED):
+        return "All checks passed successfully."
+    # all tests passed
+    return "All checks passed successfully."
+
+
+def save_irods_config(env_path: Union[Path, str], conf: dict):
+    """Save an irods environment as json in ~/.irods.
+
+    Parmeters
+    ---------
+    env_name : str
+        file name
+    """
+    env_path = Path(env_path)
+    if env_path.suffix == ".json":
+        _write_json(env_path, conf)
+    else:
+        raise ValueError("Filetype needs to be '.json'.")
+
+
+def _read_json(file_path: Path) -> dict:
+    with open(file_path, "r", encoding="utf-8") as handle:
+        return json.load(handle)
+
+
+def _write_json(file_path: Path, content: dict):
+    with open(file_path, "w", encoding="utf-8") as handle:
+        json.dump(content, handle)

ibridgesgui/gui_utils.py

@@ -0,0 +1,118 @@
+"""Handy and reusable functions for the GUI."""
+
+import pathlib
+from typing import Union
+
+import irods
+import PyQt6
+from ibridges import IrodsPath, download
+
+from ibridgesgui.config import get_last_ienv_path, is_session_from_config
+
+try:
+    from importlib.resources import files
+except ImportError:
+    from importlib_resources import files
+
+
+UI_FILE_DIR = files(__package__) / "ui_files"
+
+
+# Widget utils
+def populate_table(table_widget, rows: int, data_by_row: list):
+    """Populate a table-like pyqt widget with data."""
+    table_widget.setRowCount(rows)
+    for row, data in enumerate(data_by_row):
+        for col, item in enumerate(data):
+            table_widget.setItem(row, col, PyQt6.QtWidgets.QTableWidgetItem(str(item)))
+    table_widget.resizeColumnsToContents()
+
+
+def populate_textfield(text_widget, text_by_row: Union[str, list]):
+    """Populate a text viewer or editor with text."""
+    text_widget.clear()
+    if isinstance(text_by_row, str):
+        text_widget.append(text_by_row)
+    else:
+        for row in text_by_row:
+            text_widget.append(row)
+
+
+# iBridges/iRODS utils
+def get_irods_item(irods_path: IrodsPath):
+    """Get the item behind an iRODS path."""
+    if irods_path.collection_exists():
+        item = irods_path.collection
+    else:
+        item = irods_path.dataobject
+    return item
+
+
+def get_coll_dict(root_coll: irods.collection.iRODSCollection) -> dict:
+    """Create a recursive metadata dictionary for `coll`.
+
+    Parameters
+    ----------
+    root_coll : irods.collection.iRODSCollection
+        Root collection for the metadata gathering.
+
+    Returns
+    -------
+    dict
+        Keys of logical paths, values
+
+    """
+    return {
+        this_coll.path: [data_obj.name for data_obj in data_objs]
+        for this_coll, _, data_objs in root_coll.walk()
+    }
+
+
+def prep_session_for_copy(session, error_label) -> pathlib.Path:
+    """Either return a save path to create a new session from or sets message in error label."""
+    if is_session_from_config(session):
+        return pathlib.Path.home().joinpath(".irods", get_last_ienv_path())
+
+    text = "The ibridges config changed during the session."
+    text += "Please reset or restart the session."
+    error_label.setText(text)
+    return None
+
+
+def combine_diffs(session, sources: list, destination: Union[IrodsPath, pathlib.Path]) -> dict:
+    """Combine the diffs of several upload or download dry-runs."""
+    combined_diffs = {
+        "create_dir": set(),
+        "create_collection": set(),
+        "upload": [],
+        "download": [],
+        "resc_name": "",
+        "options": None,
+    }
+    if isinstance(destination, pathlib.Path):
+        for ipath in sources:
+            diff = download(session, ipath, destination, dry_run=True, overwrite=True)
+            combined_diffs["download"].extend(diff["download"])
+            combined_diffs["create_dir"] = combined_diffs["create_dir"].union(diff["create_dir"])
+    elif isinstance(destination, IrodsPath):
+        print("not implemented yet")
+    return combined_diffs
+
+
+# OS utils
+def get_downloads_dir() -> pathlib.Path:
+    """Find the platform-dependent 'Downloads' directory.
+
+    Returns
+    -------
+    pathlib.Path
+        Absolute path to 'Downloads' directory.
+
+    """
+    # Linux and Mac Download folders
+    if pathlib.Path.home().joinpath("Downloads").is_dir():
+        return pathlib.Path.home().joinpath("Downloads")
+
+    # Try to create Downloads
+    pathlib.Path.home().joinpath("Downloads").mkdir(parents=True)
+    return pathlib.Path.home().joinpath("Downloads")

ibridgesgui/info.py

@@ -0,0 +1,53 @@
+"""Provide the GUI with iRODS information."""
+
+import sys
+
+import PyQt6
+import PyQt6.QtWidgets
+import PyQt6.uic
+from ibridges.resources import Resources
+
+from ibridgesgui.config import CONFIG_DIR
+from ibridgesgui.gui_utils import UI_FILE_DIR, populate_table, populate_textfield
+from ibridgesgui.ui_files.tabInfo import Ui_tabInfo
+
+
+class Info(PyQt6.QtWidgets.QWidget, Ui_tabInfo):
+    """Set iRODS information in the GUI."""
+
+    def __init__(self, session):
+        """Initialise the tab."""
+        super().__init__()
+        if getattr(sys, "frozen", False):
+            super().setupUi(self)
+        else:
+            PyQt6.uic.loadUi(UI_FILE_DIR / "tabInfo.ui", self)
+        self.session = session
+
+        self.refresh_button.clicked.connect(self.refresh_info)
+        self.refresh_info()
+
+    def refresh_info(self):
+        """Find and set the information of the connected iRODS system."""
+        self.resc_table.setRowCount(0)
+        self.setCursor(PyQt6.QtGui.QCursor(PyQt6.QtCore.Qt.CursorShape.WaitCursor))
+        # irods Zone
+        self.zone_label.setText(self.session.zone)
+        # irods user
+        self.user_label.setText(self.session.username)
+        # irods user type and groups
+        user_type, user_groups = self.session.get_user_info()
+        self.type_label.setText(user_type)
+        populate_textfield(self.groups_browser, user_groups)
+        # ibridges log location
+        self.log_label.setText(str(CONFIG_DIR))
+        # default resource
+        self.resc_label.setText(self.session.default_resc)
+        # irods server and version
+        self.server_label.setText(self.session.host)
+        self.version_label.setText(".".join((str(num) for num in self.session.server_version)))
+        # irods resources
+        resc_info = Resources(self.session).root_resources
+        populate_table(self.resc_table, len(resc_info[0]), resc_info)
+        self.resc_table.resizeColumnsToContents()
+        self.setCursor(PyQt6.QtGui.QCursor(PyQt6.QtCore.Qt.CursorShape.ArrowCursor))

ibridgesgui/irods_tree_model.py

@@ -0,0 +1,158 @@
+"""Tree model for IRODS collections.
+
+The IRODS database is huge and retrieving a complete tree of all files
+can take ages.  To improve the loading time the tree is only grown as
+far as it displays.
+"""
+
+import irods
+import irods.exception
+import PyQt6
+import PyQt6.QtCore
+import PyQt6.QtGui
+import PyQt6.QtWidgets
+from ibridges import IrodsPath
+
+
+class IrodsTreeModel(PyQt6.QtGui.QStandardItemModel):
+    """Model for an iRODS tree view."""
+
+    def __init__(self, tree_view, irods_root_path: IrodsPath):
+        """Initialise the tree view with the root node and first level.
+
+        Class variables 'user_groups' and 'base_path' _must_ be
+        populated with a list of group names and the path name of the
+        iRODS top-level collection (i.e., /<zone name>/home),
+        respectively.
+
+        Parameters
+        ----------
+        tree_view : PyQt6.QtWidgets
+            Defined iRODS tree view UI element.
+        session : ibridges.Session
+            A valid session to iRODS
+        irods_root_path : IrodsPath
+            The root collection for the tree
+
+        """
+        super().__init__()
+        self.tree_view = tree_view
+        self.session = irods_root_path.session
+        self.irods_root_path = irods_root_path
+        # Empty tree
+        self.clear()
+
+    def _tree_row_from_irods_item(self, item, parent_id, level, display_path=False):
+        icon_provider = PyQt6.QtWidgets.QFileIconProvider()
+        if display_path:
+            display = PyQt6.QtGui.QStandardItem(item.path)
+        else:
+            display = PyQt6.QtGui.QStandardItem(item.name)
+        if isinstance(item, irods.collection.iRODSCollection):
+            display.setIcon(icon_provider.icon(PyQt6.QtWidgets.QFileIconProvider.IconType.Folder))
+            datatype = "C"
+        else:
+            display.setIcon(icon_provider.icon(PyQt6.QtWidgets.QFileIconProvider.IconType.File))
+            datatype = "d"
+        row = [
+            display,  # display name
+            PyQt6.QtGui.QStandardItem(str(level + 1)),  # item level in the tree
+            PyQt6.QtGui.QStandardItem(str(item.id)),  # id in iRODS
+            PyQt6.QtGui.QStandardItem(str(parent_id)),  # parent id
+            PyQt6.QtGui.QStandardItem(datatype),  # C or d
+            PyQt6.QtGui.QStandardItem(item.path),  # absolute irods path
+        ]
+        return row
+
+    def init_tree(self):
+        """Draw the first levels of an iRODS filesystem as a tree."""
+        self.setRowCount(0)
+        root = self.invisibleRootItem()
+
+        # Start the tree, add the highest level to the invisible root
+        root_coll = IrodsPath(self.session, self.irods_root_path).collection
+        root_row = self._tree_row_from_irods_item(root_coll, -1, -1, True)
+        root.appendRow(root_row)
+
+        new_node = root.child(root.rowCount() - 1)
+
+        # insert a dummy child to get the link to open the collection
+        new_node.appendRow(None)
+
+    def delete_subtree(self, tree_item):
+        """Delete subtree.
+
+        Parameters
+        ----------
+        tree_item : QStandardItem
+            Item in the QTreeView
+
+        """
+        # Remove all children from tree_item
+        tree_item.removeRows(0, tree_item.rowCount())
+
+    def add_subtree(self, tree_item, tree_item_data: list):
+        """Grow tree_view from tree_item.
+
+        Parameters
+        ----------
+        tree_item : PyQt6.QtGui.QStandardItem
+            The root of the subtree in the tree view
+        tree_item_data : list
+            [display_name, level, id, parent_id, 'C/d', absolute iRODS Path]
+
+        """
+        _, level, _, _, _, abs_irods_path = tree_item_data
+        parent_coll = IrodsPath(self.session, abs_irods_path).collection
+
+        # we assume that tree_item has no children yet.
+        new_nodes = {}
+        for item in parent_coll.subcollections + parent_coll.data_objects:
+            row = self._tree_row_from_irods_item(item, parent_coll.id, int(level))
+            tree_item.appendRow(row)
+            new_nodes[item.id] = tree_item.child(tree_item.rowCount() - 1)
+            if isinstance(item, irods.collection.iRODSCollection):
+                # insert a dummy child to get the link to open the collection
+                new_nodes[item.id].appendRow(None)
+
+    def refresh_subtree(self, position):
+        """Refresh the tree view.
+
+        Parameters
+        ----------
+        position : PyQt6.QtCore.QModelIndex
+            Location in tree
+
+        """
+        model_index = position
+        tree_item = self.itemFromIndex(model_index)  # clicked item
+        parent = tree_item.parent()
+        if parent is None:
+            parent = self.invisibleRootItem()
+        row = tree_item.row()
+
+        # retrieve information of clicked item, the information is stored in its parent
+        tree_item_data = [parent.child(row, col).data(0) for col in range(parent.columnCount())]
+        irods_path = IrodsPath(self.session, tree_item_data[-1])
+        if irods_path.collection_exists():
+            # Delete subtree in irodsFsdata and the tree_view.
+            self.delete_subtree(tree_item)
+            self.add_subtree(tree_item, tree_item_data)
+
+    def irods_path_from_tree_index(self, model_index):
+        """Convert a tree index to iRODS path.
+
+        Parameters
+        ----------
+        model_index : PyQt6.QtCore.QModelIndex
+            Selected row in tree view
+
+        """
+        tree_item = self.itemFromIndex(model_index)  # clicked item
+        row = tree_item.row()
+
+        parent = tree_item.parent()  # contains the data of tree_item
+        if parent is None:
+            parent = self.invisibleRootItem()
+        irods_path = [parent.child(row, col).data(0) for col in range(parent.columnCount())][-1]
+        return IrodsPath(self.session, irods_path)