datalab-platform 0.0.1.dev0__py3-none-any.whl → 1.0.1__py3-none-any.whl

datalab/widgets/connection.py

@@ -0,0 +1,138 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Module providing a connection dialog box for the DataLab proxy client
+"""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Callable
+
+from guidata.configtools import get_icon, get_image_file_path
+from guidata.qthelpers import (
+    get_std_icon,
+    qt_app_context,
+    win32_fix_title_bar_background,
+)
+from qtpy import QtCore as QC
+from qtpy import QtGui as QG
+from qtpy import QtWidgets as QW
+
+from datalab.config import _
+
+
+class ConnectionThread(QC.QThread):
+    """DataLab Connection thread"""
+
+    SIG_CONNECTION_OK = QC.Signal()
+    SIG_CONNECTION_KO = QC.Signal(str)
+
+    def __init__(self, connect_callback: Callable, parent: QC.QObject = None) -> None:
+        super().__init__(parent)
+        self.connect_callback = connect_callback
+
+    def run(self) -> None:
+        """Run thread"""
+        try:
+            self.connect_callback()
+            self.SIG_CONNECTION_OK.emit()
+        except ConnectionRefusedError as exc:
+            self.SIG_CONNECTION_KO.emit(str(exc))
+
+
+class ConnectionDialog(QW.QDialog):
+    """DataLab Connection dialog
+
+    Args:
+        connect_callback: Callback function to connect to DataLab server
+        parent: Parent widget. Defaults to None.
+    """
+
+    def __init__(self, connect_callback: Callable, parent: QW.QWidget = None) -> None:
+        super().__init__(parent)
+        win32_fix_title_bar_background(self)
+        self.setWindowTitle(_("Connection to DataLab"))
+        self.setWindowIcon(get_icon("DataLab.svg"))
+        self.resize(300, 50)
+        self.__error_message = ""
+        self.host_label = QW.QLabel()
+        pixmap = QG.QPixmap(get_image_file_path("DataLab-Banner-200.png"))
+        self.host_label.setPixmap(pixmap)
+        self.host_label.setAlignment(QC.Qt.AlignCenter)
+        self.progress_bar = QW.QProgressBar()
+        self.progress_bar.setRange(0, 0)
+        status = QW.QWidget()
+        status_layout = QW.QHBoxLayout()
+        status.setLayout(status_layout)
+        self.status_label = QW.QLabel("Waiting for connection...")
+        self.status_icon = QW.QLabel()
+        status_layout.addWidget(self.status_icon)
+        status_layout.addWidget(self.status_label)
+        status_layout.setContentsMargins(0, 0, 0, 0)
+        status_layout.addStretch()
+        layout = QW.QVBoxLayout()
+        layout.addWidget(self.host_label)
+        layout.addWidget(self.progress_bar)
+        layout.addWidget(status)
+        self.setLayout(layout)
+        self.thread = ConnectionThread(connect_callback)
+        self.thread.SIG_CONNECTION_OK.connect(self.__on_connection_successful)
+        self.thread.SIG_CONNECTION_KO.connect(self.__on_connection_failed)
+        button_box = QW.QDialogButtonBox(QW.QDialogButtonBox.Cancel)
+        button_box.rejected.connect(self.reject)
+        layout.addWidget(button_box)
+
+    def __set_status_icon(self, name: str) -> None:
+        """Set status icon with standard Qt icon name"""
+        self.status_icon.setPixmap(QG.QPixmap(get_std_icon(name).pixmap(24)))
+
+    def __connect_to_server(self) -> None:
+        """Connect to server"""
+        self.progress_bar.setRange(0, 0)
+        self.__set_status_icon("BrowserReload")
+        self.status_label.setText("Connecting to server...")
+        self.thread.start()
+
+    def __on_connection_successful(self) -> None:
+        """Connection successful"""
+        self.progress_bar.setRange(0, 1)
+        self.progress_bar.setValue(1)
+        self.__set_status_icon("DialogApplyButton")
+        self.status_label.setText("Connection successful!")
+        QC.QTimer.singleShot(1000, self.accept)
+
+    def __on_connection_failed(self, error_message: str) -> None:
+        """Connection failed"""
+        self.__error_message = error_message
+        self.progress_bar.setRange(0, 1)
+        self.progress_bar.setValue(1)
+        self.__set_status_icon("MessageBoxCritical")
+        self.status_label.setText(f"Connection failed: {error_message}")
+        QC.QTimer.singleShot(2000, self.reject)
+
+    def get_error_message(self) -> str:
+        """Get error message if connection failed"""
+        return self.__error_message
+
+    def exec(self) -> int:
+        """Execute dialog"""
+        self.__connect_to_server()
+        return super().exec()
+
+    def reject(self) -> None:
+        """Reject dialog"""
+        super().reject()
+        self.__error_message = "Cancelled by user"
+
+
+if __name__ == "__main__":
+
+    def fake_connect():
+        """Fake connection"""
+        time.sleep(5)
+        # raise ConnectionRefusedError("Connection refused")
+
+    with qt_app_context():
+        dlg = ConnectionDialog(fake_connect)
+        dlg.exec()

datalab/widgets/filedialog.py

@@ -0,0 +1,91 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Module providing a file dialog widget based on Qt's QFileDialog.getOpenFileNames
+but supporting multiple file preselection (Qt original dialog only supports single file
+selection).
+"""
+
+from __future__ import annotations
+
+import os
+import os.path as osp
+
+from guidata.qthelpers import qt_app_context
+from qtpy.QtCore import QItemSelectionModel
+from qtpy.QtWidgets import QAbstractItemView, QFileDialog, QListView, QWidget
+
+
+def get_open_file_names(
+    parent: QWidget | None = None,
+    caption: str = "",
+    basedir: str | list[str] = "",
+    filters: str = "",
+    selectedfilter: str = "",
+    options: QFileDialog.Options = None,
+) -> tuple[list[str], str]:
+    """Wrapper around QtGui.QFileDialog.getOpenFileNames static method
+    Returns a tuple (filenames, selectedfilter) -- when dialog box is canceled,
+    returns a tuple (empty list, empty string)
+
+    Args:
+        parent: Parent widget for the dialog.
+        caption: Dialog title.
+        basedir: Initial directory to open the dialog in, or preselected files
+         (single string or list of strings).
+        filters: File filters for the dialog.
+        selectedfilter: Default filter to be selected.
+        options: Additional options for the dialog.
+
+    Returns:
+        A tuple containing a list of selected filenames and the selected filter.
+    """
+    if isinstance(basedir, str):
+        if osp.isfile(basedir):
+            sel_files = [basedir]
+            basedir = osp.dirname(basedir)
+        else:
+            sel_files = []
+    else:
+        assert isinstance(basedir, list)
+        sel_files = basedir
+        basedir = osp.dirname(sel_files[0]) if sel_files else ""
+    dlg = QFileDialog(
+        parent, caption, basedir, filters, options=QFileDialog.DontUseNativeDialog
+    )
+    if options is not None:
+        dlg.setOptions(options | QFileDialog.DontUseNativeDialog)
+    file_view = dlg.findChild(QListView, "listView")
+    sel_model = file_view.selectionModel()
+    for fname in sel_files:
+        idx = sel_model.model().index(fname)
+        sel_model.select(idx, QItemSelectionModel.Select | QItemSelectionModel.Rows)
+    file_view.setSelectionMode(QAbstractItemView.ExtendedSelection)
+    file_view.setSelectionBehavior(QAbstractItemView.SelectRows)
+    if dlg.exec():
+        filenames = dlg.selectedFiles()
+        selectedfilter = dlg.selectedNameFilter()
+    else:
+        filenames = []
+        selectedfilter = ""
+    return filenames, selectedfilter
+
+
+def test_get_open_file_names():
+    """Test get_open_file_names function"""
+    datalab_widgets_path = osp.dirname(__file__)
+    sel_files = [
+        osp.join(datalab_widgets_path, fname)
+        for fname in os.listdir(datalab_widgets_path)[:2]
+    ]
+    with qt_app_context():
+        filenames, selectedfilter = get_open_file_names(
+            filters="Python files (*.py);;All files (*)",
+            caption="Select Python files",
+            basedir=sel_files,
+        )
+        print(filenames, selectedfilter)
+
+
+if __name__ == "__main__":
+    test_get_open_file_names()

datalab/widgets/fileviewer.py

@@ -0,0 +1,84 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Module providing a file viewer widget
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from guidata.widgets.codeeditor import CodeEditor
+from qtpy import QtWidgets as QW
+
+from datalab.config import _
+
+
+def read_text_file(path: str) -> str:
+    """Read text file using multiple encodings
+
+    Args:
+        path (str): path to file
+
+    Raises:
+        UnicodeDecodeError: if unable to read file using any of the encodings
+
+    Returns:
+        str: file contents
+    """
+    encodings = ["utf-8", "latin1", "cp1252", "utf-16", "utf-32", "ascii"]
+    for encoding in encodings:
+        try:
+            with open(path, "r", encoding=encoding) as fdesc:
+                return fdesc.read()
+        except UnicodeDecodeError:
+            pass
+    raise UnicodeDecodeError(
+        f"Unable to read file using the following encodings: {encodings}"
+    )
+
+
+def get_title_contents(path: str) -> tuple[str, str]:
+    """Get title and contents for log filename
+
+    Args:
+        path (str): path to file
+
+    Returns:
+        tuple[str, str]: title and contents
+    """
+    contents = read_text_file(path)
+    pathobj = Path(path)
+    uri_path = pathobj.absolute().as_uri()
+    prefix = _("Contents of file")
+    text = f'{prefix} <a href="{uri_path}">{path}</a>:'
+    return text, contents
+
+
+class FileViewerWidget(QW.QWidget):
+    """File viewer widget
+
+    Args:
+        parent (QW.QWidget | None): parent widget. Defaults to None.
+    """
+
+    def __init__(self, language: str | None = None, parent: QW.QWidget = None) -> None:
+        super().__init__(parent)
+        self.editor = CodeEditor(language=language)
+        self.editor.setReadOnly(True)
+        layout = QW.QVBoxLayout()
+        self.label = QW.QLabel("")
+        layout.addWidget(self.label)
+        layout.addWidget(self.editor)
+        self.setLayout(layout)
+
+    def set_data(self, text: str, contents: str) -> None:
+        """Set log data
+
+        Args:
+            text (str): text to display
+            contents (str): contents to display
+        """
+        self.label.setText(text)
+        self.label.setOpenExternalLinks(True)
+        self.editor.setPlainText(contents)