cellxgene/server/gui/main.py

# flake8: noqa F403, F405
from functools import partialmethod
from multiprocessing import Pipe, Process
from os import environ
from os.path import splitext, basename, dirname, join
import sys
import threading

from cefpython3 import cefpython as cef
import PySide2
from PySide2.QtGui import *
from PySide2.QtCore import *
from PySide2.QtWidgets import *

import server.gui.cellxgene_rc
from server.gui.browser import CefWidget, CefApplication
from server.gui.options_parser import parse_opt_string
from server.cli.launch import parse_engine_args
from server.gui.workers import Worker, SiteReadyWorker
from server.gui.utils import WINDOWS, LINUX, MAC, FileLoadSignals, Emitter, WorkerSignals, FileChanged
from server.utils.errors import OptionsError
from server.utils.utils import find_available_port

if WINDOWS or LINUX:
    dirname = dirname(PySide2.__file__)
    plugin_path = join(dirname, 'plugins', 'platforms')
    environ['QT_QPA_PLATFORM_PLUGIN_PATH'] = plugin_path

# Configuration
# TODO remember this or calculate it?
WIDTH = 1300
HEIGHT = 800
GUI_PORT = find_available_port("localhost")
BROWSER_INDEX = 0
LOAD_INDEX = 1


class MainWindow(QMainWindow):
    def __init__(self):
        super(MainWindow, self).__init__(None)
        self.cef_widget = None
        self.data_widget = None
        self.stacked_layout = None
        self.parent_conn, self.child_conn = None, None
        self.load_emitter = None
        self.emitter_thread = None
        self.worker = None
        self.url = f"http://localhost:{GUI_PORT}/"
        self.setWindowTitle("cellxgene")

        # Strong focus - accepts focus by tab & click
        self.setFocusPolicy(Qt.StrongFocus)
        self.setupLayout()
        self.setupMenu()

    def showBrowser(self):
        self.stacked_layout.setCurrentIndex(BROWSER_INDEX)

    def restartOnError(self):
        self.window().shutdownServer()
        # close emitter on error/finished
        self.parent_conn, self.child_conn = Pipe()
        self.load_emitter = Emitter(self.parent_conn, WorkerSignals)
        self.emitter_thread = threading.Thread(target=self.load_emitter.run, daemon=True)
        self.emitter_thread.start()
        # send to load with error message?

    def setupLayout(self):
        self.resize(WIDTH, HEIGHT)
        self.cef_widget = CefWidget(self)
        self.cef_widget.setSizePolicy(QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding))
        self.data_widget = LoadWidget(self)
        self.stacked_layout = QStackedLayout()
        self.stacked_layout.addWidget(self.cef_widget)
        self.stacked_layout.addWidget(self.data_widget)
        main_layout = QVBoxLayout()
        main_layout.setContentsMargins(0, 0, 0, 0)
        main_layout.setSpacing(0)
        main_layout.addLayout(self.stacked_layout)
        frame = QFrame()
        frame.setLayout(main_layout)
        self.setCentralWidget(frame)

        if WINDOWS:
            # On Windows with PyQt5 main window must be shown first
            # before CEF browser is embedded, otherwise window is
            # not resized and application hangs during resize.
            self.show()

        # Browser can be embedded only after layout was set up
        self.cef_widget.embedBrowser()

        if LINUX:
            # On Linux with PyQt5 the QX11EmbedContainer widget is
            # no longer available. An equivalent in Qt5 is to create
            # a hidden window, embed CEF browser in it and then
            # create a container for that hidden window and replace
            # cef widget in the layout with the container.
            self.container = QWidget.createWindowContainer(
                self.cef_widget.hidden_window, parent=self)
            self.stacked_layout.replaceWidget(self.cef_widget, self.container)
        self.stacked_layout.setCurrentIndex(LOAD_INDEX)

    def setupServer(self):
        self.shutdownServer()
        # close emitter on error/finished
        self.parent_conn, self.child_conn = Pipe()
        self.load_emitter = Emitter(self.parent_conn, WorkerSignals)
        self.emitter_thread = threading.Thread(target=self.load_emitter.run, daemon=True)
        self.emitter_thread.start()
        # send to load with error message?

    def shutdownServer(self):
        if self.worker:
            self.worker.terminate()
        if self.parent_conn:
            self.parent_conn.close()

    def setupMenu(self):
        # TODO add communication to subprocess on reload
        main_menu = self.menuBar()
        file_menu = main_menu.addMenu('File')
        load_action = QAction("Load file...", self)
        load_action.setStatusTip("Load file")
        load_action.setShortcut("Ctrl+O")
        load_action.triggered.connect(self.showLoad)
        file_menu.addAction(load_action)

    def showLoad(self):
        self.clearMessages()
        self.stacked_layout.setCurrentIndex(LOAD_INDEX)

    def clearMessages(self):
        self.data_widget.reset()

    def closeEvent(self, event):
        # Close browser (force=True) and free CEF reference
        if self.cef_widget.browser:
            self.cef_widget.browser.CloseBrowser(True)
            self.clearBrowserReferences()

    def clearBrowserReferences(self):
        # Clear browser references that you keep anywhere in your
        # code. All references must be cleared for CEF to shutdown cleanly.
        self.cef_widget.browser = None


class LoadWidget(QFrame):
    def __init__(self, parent):
        super(LoadWidget, self).__init__(parent=parent)
        # Init layout
        self.MAX_CONTENT_WIDTH = 500
        load_ui_layout = QVBoxLayout()
        h_margin = (WIDTH - self.MAX_CONTENT_WIDTH) // 2
        if h_margin < 10:
            h_margin = 10
        load_ui_layout.setContentsMargins(h_margin, 20, h_margin, 20)
        logo_layout = QHBoxLayout()
        logo_layout.setContentsMargins(0, 0, 0, 20)

        file_layout = QVBoxLayout()

        message_layout = QHBoxLayout()
        message_layout.setContentsMargins(0, 0, 0, 0)

        self.serverError = False
        self.file_name = FilePath()

        self.label = QLabel()
        logo = QPixmap(":/logo.png")
        self.label.setPixmap(logo)
        self.label.setContentsMargins(100, 0, 100, 0)
        logo_layout.addWidget(self.label)

        # UI section
        # TODO add cancel button to send back to browser (if available)

        self.file_area = FileArea()
        self.file_name.signals.changed.connect(self.updatePath)

        self.launch_widget = QPushButton("Launch cellxgene")
        self.launch_widget.setEnabled(False)
        self.launch_widget.clicked.connect(self.onLoad)

        self.progress = QProgressBar()
        self.progress.setTextVisible(False)

        self.advanced_options = CLIOptionsArea(self)

        file_layout.addWidget(self.file_area)
        file_layout.addWidget(self.advanced_options)
        self.loading_layout = QStackedLayout()
        self.loading_layout.addWidget(self.launch_widget)
        self.loading_layout.addWidget(self.progress)
        file_layout.addLayout(self.loading_layout)
        file_layout.setStretch(0, 10)

        # Error section
        self.error_label = QLabel("")
        self.error_label.setWordWrap(True)
        self.error_label.setFixedWidth(self.MAX_CONTENT_WIDTH)
        message_layout.addWidget(self.error_label)

        # Options Form

        # Layout
        for l in [logo_layout, file_layout, message_layout]:
            load_ui_layout.addLayout(l)

        #TODO remove magic number
        load_ui_layout.setStretch(1, 10)
        self.setLayout(load_ui_layout)

        self.timer = QTimer()
        self.timer.setInterval(100)
        self.timer.timeout.connect(self.updateProgress)

        self.signals = FileLoadSignals()
        self.signals.selectedFile.connect(self.createScanpyEngine)
        self.signals.error.connect(self.onError)

    def updatePath(self):
        file_name = self.file_name.value
        if file_name:
            self.file_area.label.setText("File: " + file_name)
        else:
            self.file_area.label.setText("")
        self.launch_widget.setEnabled(bool(file_name))

    def reset(self):
        self.loading_layout.setCurrentIndex(0)
        self.timer.stop()
        self.error_label.setText("")
        self.file_name.updateValue(None)
        self.advanced_options.reset()

    def updateProgress(self):
        curr_val = self.progress.value()
        next_val = (curr_val + 1) % 100
        self.progress.setValue(next_val)

    def resetProgress(self):
        print("here i am")
        self.progress.setValue(0)
        self.loading_layout.setCurrentIndex(0)
        self.timer.stop()

    def createScanpyEngine(self, file_name):
        try:
            self.advanced_options.parse()
        except OptionsError as e:
            self.signals.error.emit(f"Options Error: {e}")
            return
        title = self.advanced_options.title
        if not title:
            title = splitext(basename(file_name))[0]
        self.window().setupServer()
        worker = Worker(self.window().parent_conn, self.window().child_conn, file_name, host="127.0.0.1",
                        port=GUI_PORT, title=title, engine_options=self.advanced_options.engine_options)
        self.window().load_emitter.signals.ready.connect(self.onDataReady)
        self.window().load_emitter.signals.engine_error.connect(self.onServerError)
        self.window().load_emitter.signals.server_error.connect(self.onServerError)
        # Error is generic error from emitter
        self.window().load_emitter.signals.error.connect(self.onServerError)
        self.window().worker = Process(target=worker.run, daemon=True)
        self.window().worker.start()
        self.window().child_conn.close()

    def onLoad(self):
        if self.file_name.value:
            # Reset error on reload
            self.serverError = False
            self.loading_layout.setCurrentIndex(1)
            self.timer.start()
            self.signals.selectedFile.emit(self.file_name.value)
        else:
            self.signals.error.emit("Please select a file before launching.")

    def onDataReady(self):
        self.site_ready_worker = SiteReadyWorker(self.window().url)
        self.site_ready_worker.signals.ready.connect(self.onServerReady)
        self.site_ready_worker.signals.error.connect(self.onServerError)

        srw_thread = threading.Thread(target=self.site_ready_worker.run, daemon=True)
        srw_thread.start()

    def onServerReady(self):
        if not self.serverError:
            self.resetProgress()
            self.window().cef_widget.browser.Navigate(self.window().url)
            self.window().showBrowser()

    def onError(self, err, server_error=False):
        # Restart worker
        if server_error:
            self.serverError = True
            # Report error and switch to load screen
        self.window().shutdownServer()
        self.resetProgress()
        self.window().stacked_layout.setCurrentIndex(LOAD_INDEX)
        self.error_label.setText(f"Error: {err}")
        self.error_label.resize(self.MAX_CONTENT_WIDTH, self.error_label.height())
        self.window().repaint()

    onServerError = partialmethod(onError, server_error=True)

class CLIOptionsArea(QFrame):
    def __init__(self, parent):
        super(CLIOptionsArea, self).__init__(parent)
        self.engine_options = {}
        self.setFixedWidth(500)
        self.title = None
        self.form_layout = QFormLayout()
        self.form_layout.setContentsMargins(0,0,0,0)
        self.cli_label = QLabel("CLI Options:")
        self.cli_label.setToolTip("Additional options can be passed as cli parameters. See cellxgene --help for more info")
        self.cli_widget = QLineEdit()
        self.form_layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
        self.form_layout.addRow(self.cli_label, self.cli_widget)
        self.setLayout(self.form_layout)

    def reset(self):
        self.cli_widget.setText("")
        self.engine_options = {}
        self.title = None

    def parse(self):
        opts = parse_opt_string(self.cli_widget.text())
        self.title = opts.pop("title", None)
        self.engine_options = parse_engine_args(**opts)


class FilePath(QObject):
    def __init__(self):
        super(FilePath, self).__init__()
        self.value = ""
        self.signals = FileChanged()

    def updateValue(self, path=None):
        self.value = path
        self.signals.changed.emit(self.value != path)


class FileArea(QFrame):
    def __init__(self):
        super(FileArea, self).__init__()
        self.setFrameShape(QFrame.Box)
        self.setMinimumHeight(100)
        self.setFixedWidth(500)
        self.setAcceptDrops(True)
        self.instructions = QLabel(self)
        self.instructions.setText("Drag & Drop a h5ad file to load or open")
        self.instructions.setGeometry(10, 10, 500, self.instructions.height())
        self.loadButton = QPushButton("Open...", parent=self)
        x_pos = (500 - self.loadButton.width()) / 2
        self.loadButton.setGeometry(x_pos, 50, self.loadButton.width(), self.loadButton.height())
        self.loadButton.clicked.connect(self.fileBrowse)
        self.label = QLabel(self)
        self.label.setGeometry(10, 75, 500, self.label.height())

    def fileBrowse(self):
        options = QFileDialog.Options()
        # options |= QFileDialog.DontUseNativeDialog
        file_name, _ = QFileDialog.getOpenFileName(self,
                                                   "Open H5AD File", "", "H5AD Files (*.h5ad)", options=options)
        if file_name:
            self.parent().file_name.updateValue(file_name)

    def dragEnterEvent(self, e):
        if e.mimeData().hasUrls:
            e.accept()
        else:
            e.ignore()

    def dragMoveEvent(self, e):
        if e.mimeData().hasUrls:
            e.accept()
        else:
            e.ignore()

    def dropEvent(self, e):
        """
        Drop files directly onto the widget
        File locations are stored in fname
        :param e:
        :return:
        """
        if e.mimeData().hasUrls:
            e.setDropAction(Qt.CopyAction)
            e.accept()
            for url in e.mimeData().urls():
                file_name = str(url.toLocalFile())
            self.parent().file_name.updateValue(file_name)
        else:
            e.ignore()


def main():
    # This generates an error.log file on error
    sys.excepthook = cef.ExceptHook  # To shutdown all CEF processes on error
    settings = {}
    # Instead of timer loop
    if MAC:
        settings["external_message_pump"] = True

    # Create and launch cef browser and qt window
    cef.Initialize(settings)
    app = CefApplication(sys.argv)
    main_window = MainWindow()
    main_window.setWindowTitle("cellxgene")
    main_window.setUnifiedTitleAndToolBarOnMac(True)
    main_window.setWindowIcon(QIcon(":icon.png"))
    main_window.show()
    main_window.activateWindow()
    main_window.raise_()
    try:
        app.exec_()
    except Exception as e:
        raise
    finally:
        # Clean up on close
        if not cef.GetAppSetting("external_message_pump"):
            app.stopTimer()

        main_window.shutdownServer()
        del main_window  # Just to be safe, similarly to "del app"
        del app  # Must destroy app object before calling Shutdown
        cef.Shutdown()
        sys.exit(0)


if __name__ == '__main__':
    main()