qcanvas 0.0.5.7a0__py3-none-any.whl → 1.0.3.post0__py3-none-any.whl

qcanvas/ui/main_ui/qcanvas_window.py

@@ -0,0 +1,192 @@
+import logging
+from threading import Semaphore
+from typing import *
+
+import qcanvas_backend.database.types as db
+from qasync import asyncSlot
+from qcanvas_backend.database.data_monolith import DataMonolith
+from qcanvas_backend.qcanvas import QCanvas
+from qtpy.QtCore import QUrl, Signal, Slot
+from qtpy.QtGui import QDesktopServices, QKeySequence, QPixmap
+from qtpy.QtWidgets import *
+
+from qcanvas import icons
+from qcanvas.backend_connectors import FrontendResourceManager
+from qcanvas.ui.course_viewer import CourseTree
+from qcanvas.ui.main_ui.course_viewer_container import CourseViewerContainer
+from qcanvas.ui.main_ui.options.quick_sync_option import QuickSyncOption
+from qcanvas.ui.main_ui.options.sync_on_start_option import SyncOnStartOption
+from qcanvas.ui.main_ui.status_bar_progress_display import StatusBarProgressDisplay
+from qcanvas.util import paths, settings
+from qcanvas.util.ui_tools import create_qaction
+
+_logger = logging.getLogger(__name__)
+
+
+class QCanvasWindow(QMainWindow):
+    _loaded = Signal()
+
+    def __init__(self):
+        super().__init__()
+
+        self.setWindowTitle("QCanvas")
+        self.setWindowIcon(QPixmap(icons.main_icon))
+
+        self._operation_semaphore = Semaphore()
+        self._data: Optional[DataMonolith] = None
+        self._qcanvas = QCanvas[FrontendResourceManager](
+            canvas_config=settings.client.canvas_config,
+            panopto_config=settings.client.panopto_config,
+            storage_path=paths.data_storage(),
+            resource_manager_class=FrontendResourceManager,
+        )
+
+        self._course_tree = CourseTree()
+        self._course_tree.item_selected.connect(self._on_course_selected)
+        self._course_tree.course_renamed.connect(self._on_course_renamed)
+        self._sync_button = QPushButton("Synchronise")
+        self._sync_button.clicked.connect(self._synchronise_requested)
+        self._course_viewer_container = CourseViewerContainer(
+            self._qcanvas.resource_manager
+        )
+
+        self.setCentralWidget(self._setup_main_layout())
+        self.setStatusBar(StatusBarProgressDisplay())
+        self._setup_menu_bar()
+        self._restore_window_position()
+
+        self._loaded.connect(self._on_app_loaded)
+        self._loaded.emit()
+
+    def _setup_menu_bar(self) -> None:
+        menu_bar = self.menuBar()
+        app_menu = menu_bar.addMenu("Actions")
+
+        create_qaction(
+            name="Synchronise",
+            shortcut=QKeySequence("Ctrl+S"),
+            triggered=self._synchronise_requested,
+            parent=app_menu,
+        )
+
+        create_qaction(
+            name="Open downloads folder",
+            shortcut=QKeySequence("Ctrl+D"),
+            triggered=self._open_downloads_folder,
+            parent=app_menu,
+        )
+
+        create_qaction(
+            name="Quick canvas login",
+            shortcut=QKeySequence("Ctrl+O"),
+            triggered=self._open_quick_auth_in_browser,
+            parent=app_menu,
+        )
+
+        create_qaction(
+            name="Quit",
+            shortcut=QKeySequence("Ctrl+Q"),
+            triggered=lambda: self.close(),
+            parent=app_menu,
+        )
+
+        options_menu = menu_bar.addMenu("Options")
+
+        options_menu.addAction(QuickSyncOption(options_menu))
+        options_menu.addAction(SyncOnStartOption(options_menu))
+
+    def _restore_window_position(self):
+        self.restoreGeometry(settings.ui.last_geometry)
+        self.restoreState(settings.ui.last_window_state)
+
+    def closeEvent(self, event):
+        settings.ui.last_geometry = self.saveGeometry()
+        settings.ui.last_window_state = self.saveState()
+
+    def _setup_main_layout(self) -> QWidget:
+        h_box = QHBoxLayout()
+
+        h_box.addLayout(self._setup_course_column(), 1)
+        h_box.addWidget(self._course_viewer_container, 5)
+
+        widget = QWidget()
+        widget.setLayout(h_box)
+        return widget
+
+    def _setup_course_column(self) -> QVBoxLayout:
+        course_list_column = QVBoxLayout()
+        course_list_column.addWidget(self._course_tree)
+        course_list_column.addWidget(self._sync_button)
+
+        return course_list_column
+
+    @asyncSlot()
+    async def _on_app_loaded(self) -> None:
+        await self._qcanvas.init()
+        self._course_tree.reload(await self._get_terms(), sync_receipt=None)
+
+        if settings.client.sync_on_start:
+            await self._synchronise()
+
+    @asyncSlot()
+    async def _synchronise_requested(self) -> None:
+        await self._synchronise()
+
+    async def _synchronise(self) -> None:
+        if not self._operation_semaphore.acquire(False):
+            _logger.debug("Sync operation already in progress")
+            return
+
+        try:
+            # todo handle exceptions and PROGRESS!! better
+            self._sync_button.setText("Sync in progress...")
+            receipt = await self._qcanvas.synchronise_canvas(
+                quick_sync=settings.client.quick_sync_enabled
+            )
+
+            self._course_tree.reload(await self._get_terms(), sync_receipt=receipt)
+            await self._course_viewer_container.reload_all(
+                await self._get_courses(), sync_receipt=receipt
+            )
+            self._sync_button.setText("Synchronise")
+
+        finally:
+            self._operation_semaphore.release()
+
+    async def _get_terms(self) -> Sequence[db.Term]:
+        return (await self._qcanvas.get_data()).terms
+
+    async def _get_courses(self) -> Sequence[db.Course]:
+        return (await self._qcanvas.get_data()).courses
+
+    @Slot()
+    def _on_course_selected(self, course: Optional[db.Course]) -> None:
+        if course is not None:
+            self._course_viewer_container.load_course(course)
+        else:
+            self._course_viewer_container.show_blank()
+
+    @asyncSlot()
+    async def _on_course_renamed(self, course: db.Course, new_name: str) -> None:
+        _logger.debug("Rename %s -> %s", course.name, new_name)
+
+        async with self._qcanvas.database.session() as session:
+            session.add(course)
+            course.configuration.nickname = new_name
+
+    @asyncSlot()
+    async def _open_quick_auth_in_browser(self):
+        opening_progress_dialog = QProgressDialog("Opening canvas", None, 0, 0, self)
+        opening_progress_dialog.setWindowTitle("Please wait")
+        opening_progress_dialog.show()
+        QDesktopServices.openUrl(
+            await self._qcanvas.canvas_client.get_temporary_session_url()
+        )
+        opening_progress_dialog.close()
+
+    @Slot()
+    def _open_downloads_folder(self) -> None:
+        # fixme hard coded path! >:(
+        QDesktopServices.openUrl(
+            QUrl(f"file://{(paths.data_storage() / 'downloads').absolute()}")
+        )

qcanvas/ui/main_ui/status_bar_progress_display.py

@@ -0,0 +1,153 @@
+import logging
+from asyncio import Lock
+from dataclasses import dataclass
+from typing import *
+
+from qasync import asyncSlot
+from qcanvas_backend.task_master import TaskID
+from qtpy.QtWidgets import *
+
+from qcanvas.backend_connectors import task_master
+
+_logger = logging.getLogger(__name__)
+
+
+@dataclass
+class _TaskProgress:
+    current: int
+    total: int
+
+
+class StatusBarProgressDisplay(QStatusBar):
+    def __init__(self):
+        super().__init__()
+        self._lock = Lock()
+        self._tasks: dict[TaskID, _TaskProgress] = {}
+
+        self._progress_bar = self._setup_progress_bar()
+        self.addPermanentWidget(self._progress_bar)
+
+        task_master.task_progress.connect(self._on_task_progress)
+        task_master.task_failed.connect(self._on_task_failed)
+
+        self.showMessage("Ready", 5000)
+
+    def _setup_progress_bar(self) -> QProgressBar:
+        bar = QProgressBar()
+        bar.setTextVisible(True)
+        bar.hide()
+        return bar
+
+    @asyncSlot()
+    async def _on_task_progress(
+        self, task_id: TaskID, current: int, total: int
+    ) -> None:
+        _logger.debug("Progress %s: %i/%i", task_id, current, total)
+
+        async with self._lock:
+            if task_id not in self._tasks:
+                self._add_task(task_id, current, total)
+            if current == total and total != 0:
+                self._remove_task(task_id)
+            else:
+                self._update_task(task_id, current, total)
+
+        await self._update_task_status()
+
+    def _update_task(self, task_id: TaskID, current: int, total: int) -> None:
+        _logger.debug("Update %s", task_id)
+        task = self._tasks[task_id]
+        task.current = current
+        task.total = total
+
+    @asyncSlot()
+    async def _on_task_failed(self, task_id: TaskID, context: str | Exception) -> None:
+        _logger.debug("%s failed", task_id)
+
+        async with self._lock:
+            self._remove_task(task_id)
+
+            if self._has_no_tasks:
+                self._progress_bar.hide()
+
+        self.showMessage(f"Failed: {task_id.step_name}", 5000)
+
+    async def _update_task_status(self) -> None:
+        _logger.debug("Tasks: %s", self._tasks)
+        async with self._lock:
+            if self._has_no_tasks:
+                self._show_done()
+            elif self._has_single_task:
+                self._show_single_task_progress(list(self._tasks.items())[0])
+            else:
+                self._show_multiple_tasks_progress(list(self._tasks.values()))
+
+    def _show_done(self) -> None:
+        _logger.debug("Finished tasks. Tasks: %s", self._tasks)
+        self.showMessage("All tasks finished", 5000)
+        self._progress_bar.hide()
+
+    def _show_single_task_progress(self, task: Tuple[TaskID, _TaskProgress]) -> None:
+        _logger.debug("Single task %s", task)
+        id, progress = task
+
+        self._show_progress(progress)
+        self.showMessage(id.step_name)
+
+    def _show_multiple_tasks_progress(self, tasks: list[_TaskProgress]) -> None:
+        _logger.debug("Multiple tasks %s", tasks)
+        self.showMessage(f"{len(tasks)} tasks in progress")
+        self._show_progress(self._calculate_progress(tasks))
+
+    def _calculate_progress(self, tasks: list[_TaskProgress]) -> _TaskProgress:
+        # Used to represent 0..1 progress as 0..multiplier
+        multiplier = 1000
+        current_sum = 0
+        total_sum = 0
+
+        for task in tasks:
+            if task.total != 0:
+                current_sum += (task.current / task.total) * multiplier
+
+            total_sum += multiplier
+
+        _logger.debug(
+            "%s tasks, current=%i, total=%i", len(tasks), int(current_sum), total_sum
+        )
+
+        return _TaskProgress(int(current_sum), total_sum)
+
+    def _show_progress(self, progress: _TaskProgress) -> None:
+        self._progress_bar.setMaximum(progress.total)
+        self._progress_bar.setValue(progress.current)
+
+        if progress.total != 0:
+            self._progress_bar.setFormat(
+                f"{(progress.current / progress.total) * 100:.0f}%"
+            )
+        else:
+            self._progress_bar.setFormat("")
+
+        self._progress_bar.show()
+
+    def _add_task(self, task: TaskID, current: int, total: int) -> None:
+        self._tasks[task] = _TaskProgress(current, total)
+        _logger.debug("Added task %s", task)
+        _logger.debug("Tasks: %s", self._tasks)
+
+    def _remove_task(self, task: TaskID) -> None:
+        self._tasks.pop(task, None)
+        _logger.debug("Removed task %s", task)
+        _logger.debug("Tasks: %s", self._tasks)
+
+    @property
+    def _has_single_task(self) -> bool:
+        return len(self._tasks) == 1
+
+    @property
+    def _has_many_tasks(self) -> bool:
+        return len(self._tasks) > 1
+
+    @property
+    def _has_no_tasks(self) -> bool:
+        return len(self._tasks) == 0

qcanvas/ui/memory_tree/__init__.py

@@ -0,0 +1,2 @@
+from .memory_tree_widget import MemoryTreeWidget
+from .memory_tree_widget_item import MemoryTreeWidgetItem

qcanvas/ui/memory_tree/_tree_memory.py

@@ -0,0 +1,66 @@
+import logging
+from pathlib import Path
+from typing import *
+
+from lightdb import LightDB, Model
+
+from qcanvas.util import paths
+
+_logger = logging.getLogger(__name__)
+
+
+def _storage_path() -> Path:
+    path = paths.ui_storage() / "TREE.DB"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+_state_db = LightDB(str(_storage_path()))
+
+
+class _TreeState(Model, table="trees", db=_state_db):
+    tree_name: str
+    collapsed_items: List[str] = []
+
+
+def _get_or_create_state(name: str) -> _TreeState:
+    state = _TreeState.get(tree_name=name)
+
+    if state is None:
+        state = _TreeState.create(tree_name=name)
+        # Initialise the list here! Or else every instance has the same list object
+        state.collapsed_items = []
+        # Important or instances will get duplicated data in some cases
+        state.save()
+        return state
+    else:
+        return state
+
+
+class TreeMemory:
+    def __init__(self, tree_name: str):
+        self._tree_name = tree_name
+        self._state = _get_or_create_state(tree_name)
+
+    def is_expanded(self, node_id: str) -> bool:
+        return node_id in self._state.expanded_items
+
+    def expanded(self, node_id: str) -> None:
+        self.set_expanded(node_id, True)
+
+    def collapsed(self, node_id: str) -> None:
+        self.set_expanded(node_id, False)
+
+    def set_expanded(self, node_id: str, expanded: bool) -> None:
+        contains = node_id in self._state.collapsed_items
+
+        if expanded and contains:
+            self._state.collapsed_items.remove(node_id)
+            self._state.save()
+        elif not expanded and not contains:
+            self._state.collapsed_items.append(node_id)
+            self._state.save()
+
+    @property
+    def collapsed_ids(self) -> List[str]:
+        return self._state.collapsed_items

qcanvas/ui/memory_tree/memory_tree_widget.py

@@ -0,0 +1,133 @@
+import logging
+from typing import *
+
+from qtpy.QtCore import QItemSelectionModel, Slot
+from qtpy.QtWidgets import QTreeWidget, QTreeWidgetItem, QWidget
+
+from qcanvas.ui.memory_tree._tree_memory import TreeMemory
+from qcanvas.ui.memory_tree.memory_tree_widget_item import MemoryTreeWidgetItem
+
+_logger = logging.getLogger(__name__)
+
+
+class MemoryTreeWidget(QTreeWidget):
+    def __init__(
+        self,
+        tree_name: str,
+        parent: Optional[QWidget] = None,
+    ):
+        super().__init__(parent)
+        self._id_map: dict[str, MemoryTreeWidgetItem] = {}
+        self._memory = TreeMemory(tree_name)
+        self._suppress_expansion_signals = False
+        self._suppress_selection_signal = False
+
+        self.itemExpanded.connect(self._expanded)
+        self.itemCollapsed.connect(self._collapsed)
+
+    def reexpand(self) -> None:
+        self.scheduleDelayedItemsLayout()
+
+        try:
+            self._suppress_expansion_signals = True
+
+            collapsed_ids = self._memory.collapsed_ids
+
+            for widget in self._id_map.values():
+                if widget.id not in collapsed_ids:
+                    _logger.debug("Re-expand %s", widget.id)
+                    self.expand(self.indexFromItem(widget, 0))
+        finally:
+            self._suppress_expansion_signals = False
+
+    def clear(self):
+        super().clear()
+        self._id_map.clear()
+
+    def select_ids(self, ids: List[str]) -> bool:
+        """
+        :returns: True if all ids were still found in the tree, False if one or more was missing
+        """
+        self._suppress_selection_signal = True
+
+        is_first = True
+        all_ids_in_tree = True
+
+        try:
+            for widget_id in ids:
+                if widget_id in self._id_map:
+                    _logger.debug("Selected %s", widget_id)
+
+                    flags = (
+                        QItemSelectionModel.SelectionFlag.Rows
+                        | QItemSelectionModel.SelectionFlag.Select
+                    )
+
+                    if is_first:
+                        flags |= QItemSelectionModel.SelectionFlag.Clear
+
+                    self.selectionModel().select(
+                        self.indexFromItem(self._id_map[widget_id], 0), flags
+                    )
+                else:
+                    _logger.debug(
+                        "Item %s is no longer in the tree, can't select it", widget_id
+                    )
+                    all_ids_in_tree = False
+        finally:
+            self._suppress_selection_signal = False
+
+        return all_ids_in_tree
+
+    def insertTopLevelItem(self, index: int, item: QTreeWidgetItem):
+        super().insertTopLevelItem(index, item)
+        self._add_widget_to_id_map(item)
+
+    def insertTopLevelItems(self, index: int, items: Sequence[QTreeWidgetItem]):
+        super().insertTopLevelItems(index, items)
+        self._add_widget_to_id_map(items)
+
+    def addTopLevelItems(self, items: Sequence[QTreeWidgetItem]):
+        super().addTopLevelItems(items)
+        self._add_widget_to_id_map(items)
+
+    def _add_widget_to_id_map(
+        self, widget: QTreeWidgetItem | Sequence[QTreeWidgetItem]
+    ):
+        map_updates = {}
+        widget_stack = widget if isinstance(widget, List) else [widget]
+
+        while len(widget_stack) > 0:
+            item = widget_stack.pop()
+
+            if isinstance(item, MemoryTreeWidgetItem):
+                if item.id in self._id_map or item.id in map_updates:
+                    raise ValueError(f"Item with ID {item.id} is already in the tree")
+
+                map_updates[item.id] = item
+                _logger.debug("Add %s to map", item.id)
+
+            if item.childCount() > 0:
+                widget_stack.extend(
+                    [item.child(index) for index in range(0, item.childCount())]
+                )
+
+        self._id_map.update(map_updates.items())
+
+    @Slot()
+    def _expanded(self, item: QTreeWidgetItem):
+        if self._suppress_expansion_signals:
+            return
+
+        if isinstance(item, MemoryTreeWidgetItem):
+            _logger.debug("Expanded %s", item.id)
+            self._memory.expanded(item.id)
+
+    @Slot()
+    def _collapsed(self, item: QTreeWidgetItem):
+        if self._suppress_expansion_signals:
+            return
+
+        if isinstance(item, MemoryTreeWidgetItem):
+            _logger.debug("Collapsed %s", item.id)
+            self._memory.collapsed(item.id)

qcanvas/ui/memory_tree/memory_tree_widget_item.py

@@ -0,0 +1,19 @@
+import logging
+from typing import *
+
+from qtpy.QtWidgets import QTreeWidgetItem
+
+_logger = logging.getLogger(__name__)
+
+
+class MemoryTreeWidgetItem(QTreeWidgetItem):
+    def __init__(
+        self, id: str, data: Optional[object], strings: Optional[List[str]] = None
+    ):
+        super().__init__(strings)
+        self._id = id
+        self.extra_data = data
+
+    @property
+    def id(self) -> str:
+        return self._id

qcanvas/ui/setup/__init__.py

@@ -0,0 +1,2 @@
+from .setup_checker import needs_setup
+from .setup_dialog import SetupDialog

qcanvas/ui/setup/setup_checker.py

@@ -0,0 +1,17 @@
+import logging
+
+import qcanvas.util.settings as settings
+from qcanvas.util import is_url
+
+_logger = logging.getLogger(__name__)
+
+
+def needs_setup() -> bool:
+    if not is_url(settings.client.panopto_url):
+        return True
+    elif not is_url(settings.client.canvas_url):
+        return True
+    elif len(settings.client.canvas_api_key) == 0:
+        return True
+    else:
+        return False