cellxgene/server/gui/main.py

# flake8: noqa F403, F405
from multiprocessing import Pipe, Process
from os.path import splitext, basename
import sys
import threading

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

from server.gui.browser import CefWidget, CefApplication
from server.gui.workers import Worker, SiteReadyWorker
from server.gui.utils import WINDOWS, LINUX, MAC, FileLoadSignals, Emitter, WorkerSignals
from server.utils.constants import MODES
from server.utils.utils import find_available_port


# Configuration
# TODO remember this or calculate it?
WIDTH = 1024
HEIGHT = 768
GUI_PORT = find_available_port("localhost")

class MainWindow(QMainWindow):
    def __init__(self):
        super(MainWindow, self).__init__(None)
        self.cef_widget = None
        self.data_widget = None
        self.parent_conn, self.child_conn = Pipe()
        self.load_emitter = Emitter(self.parent_conn, WorkerSignals)
        self.load_emitter.signals.error.connect(self.restartOnError)
        self.emitter_thread = threading.Thread(target=self.load_emitter.run, daemon=True)
        self.emitter_thread.start()
        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 restartOnError(self):
        if self.worker:
            self.worker.terminate()
        self.parent_conn.close()
        # 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.data_widget = LoadWidget(self)
        self.stacked_layout = QStackedLayout()
        self.stacked_layout.addWidget(self.data_widget)
        self.stacked_layout.addWidget(self.cef_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.addWidget(self.container, 1, 0)

    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.stacked_layout.setCurrentIndex(0)

    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)

        load_layout = QGridLayout()
        load_layout.setContentsMargins(0, 0, 0, 0)
        load_layout.setSpacing(0)
        message_layout = QHBoxLayout()
        message_layout.setContentsMargins(0, 0, 0, 0)

        self.serverError = False
        self.title = ""
        self.label = QLabel("cellxgene")
        logo_layout.addWidget(self.label)

        # UI section
        # TODO add load spinner
        # TODO add cancel button to send back to browser (if available)
        self.embedding_label = QLabel("embedding: ")
        load_layout.addWidget(self.embedding_label, 0, 0)
        self.file_label = QLabel("file: ")
        load_layout.addWidget(self.file_label, 0, 1)
        self.embeddings = QComboBox(self)
        self.embeddings.currentIndexChanged.connect(self.updateEmbedding)
        self.embeddings.addItems(MODES)
        self.embedding_selection = [MODES[0]]
        load_layout.addWidget(self.embeddings, 1, 0)

        self.load = QPushButton("Open...")
        self.load.clicked.connect(self.onLoad)
        load_layout.addWidget(self.load, 1, 1)

        # 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, alignment=Qt.AlignTop)

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

        load_ui_layout.setStretch(2, 10)
        self.setLayout(load_ui_layout)

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

    def updateEmbedding(self, idx):
        self.embedding_selection = [MODES[idx]]

    def createScanpyEngine(self, file_name):
        worker = Worker(self.window().parent_conn, self.window().child_conn, file_name, self.title, host="127.0.0.1", port=GUI_PORT,
                        layout=self.embedding_selection)
        self.window().load_emitter.signals.ready.connect(self.onDataReady)
        self.window().load_emitter.signals.engine_error.connect(self.onEngineError)
        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):
        options = QFileDialog.Options()
        # options |= QFileDialog.DontUseNativeDialog
        file_name, _ = QFileDialog.getOpenFileName(self,
                                                  "Open H5AD File", "", "H5AD Files (*.h5ad)", options=options)
        self.title = splitext(basename(file_name))[0]
        if file_name:
            self.signals.selectedFile.emit(file_name)
            # Reset error on reload
            self.serverError = False

    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.onDataError)

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

    def onServerReady(self):
        if not self.serverError:
            self.window().cef_widget.browser.Navigate(self.window().url)
            self.window().stacked_layout.setCurrentIndex(1)

    def onServerError(self, err):
        # Restart worker
        self.serverError = True
        # Report error and switch to load screen
        self.window().restartOnError()
        self.window().stacked_layout.setCurrentIndex(0)
        self.error_label.setText(f"Error: {err}")
        self.error_label.resize(self.MAX_CONTENT_WIDTH, self.error_label.height())

    def onEngineError(self, err):
        self.window().restartOnError()
        self.window().stacked_layout.setCurrentIndex(0)
        self.error_label.setText(f"Error: {err}")
        self.error_label.resize(self.MAX_CONTENT_WIDTH, self.error_label.height())

    def onDataError(self, err):
        self.window().restartOnError()
        self.window().stacked_layout.setCurrentIndex(0)
        self.error_label.setText(f"Error: {err}")
        self.error_label.resize(self.MAX_CONTENT_WIDTH, self.error_label.height())


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.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()

        if main_window.worker:
            main_window.worker.terminate()
        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()