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

qcanvas/icons/sync.svg

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?><!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg width="800px" height="800px" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+    <path d="M18.43 4.25C18.2319 4.25259 18.0426 4.33244 17.9025 4.47253C17.7625 4.61263 17.6826 4.80189 17.68 5V7.43L16.84 6.59C15.971 5.71363 14.8924 5.07396 13.7067 4.73172C12.5209 4.38948 11.2673 4.35604 10.065 4.63458C8.86267 4.91312 7.7515 5.49439 6.83703 6.32318C5.92255 7.15198 5.23512 8.20078 4.84001 9.37C4.79887 9.46531 4.77824 9.56821 4.77947 9.67202C4.7807 9.77583 4.80375 9.87821 4.84714 9.97252C4.89052 10.0668 4.95326 10.151 5.03129 10.2194C5.10931 10.2879 5.20087 10.3392 5.30001 10.37C5.38273 10.3844 5.4673 10.3844 5.55001 10.37C5.70646 10.3684 5.85861 10.3186 5.98568 10.2273C6.11275 10.136 6.20856 10.0078 6.26001 9.86C6.53938 9.0301 7.00847 8.27681 7.63001 7.66C8.70957 6.58464 10.1713 5.98085 11.695 5.98085C13.2188 5.98085 14.6805 6.58464 15.76 7.66L16.6 8.5H14.19C13.9911 8.5 13.8003 8.57902 13.6597 8.71967C13.519 8.86032 13.44 9.05109 13.44 9.25C13.44 9.44891 13.519 9.63968 13.6597 9.78033C13.8003 9.92098 13.9911 10 14.19 10H18.43C18.5289 10.0013 18.627 9.98286 18.7186 9.94565C18.8102 9.90844 18.8934 9.85324 18.9633 9.78333C19.0333 9.71341 19.0885 9.6302 19.1257 9.5386C19.1629 9.44699 19.1814 9.34886 19.18 9.25V5C19.18 4.80109 19.101 4.61032 18.9603 4.46967C18.8197 4.32902 18.6289 4.25 18.43 4.25Z"
+          fill="#000000"/>
+    <path d="M18.68 13.68C18.5837 13.6422 18.4808 13.6244 18.3774 13.6277C18.274 13.6311 18.1724 13.6555 18.0787 13.6995C17.9851 13.7435 17.9015 13.8062 17.8329 13.8836C17.7643 13.9611 17.7123 14.0517 17.68 14.15C17.4006 14.9799 16.9316 15.7332 16.31 16.35C15.2305 17.4254 13.7688 18.0291 12.245 18.0291C10.7213 18.0291 9.25957 17.4254 8.18001 16.35L7.34001 15.51H9.81002C10.0089 15.51 10.1997 15.431 10.3403 15.2903C10.481 15.1497 10.56 14.9589 10.56 14.76C10.56 14.5611 10.481 14.3703 10.3403 14.2297C10.1997 14.089 10.0089 14.01 9.81002 14.01H5.57001C5.47115 14.0086 5.37302 14.0271 5.28142 14.0643C5.18982 14.1016 5.1066 14.1568 5.03669 14.2267C4.96677 14.2966 4.91158 14.3798 4.87436 14.4714C4.83715 14.563 4.81867 14.6611 4.82001 14.76V19C4.82001 19.1989 4.89903 19.3897 5.03968 19.5303C5.18034 19.671 5.3711 19.75 5.57001 19.75C5.76893 19.75 5.95969 19.671 6.10034 19.5303C6.241 19.3897 6.32001 19.1989 6.32001 19V16.57L7.16001 17.41C8.02901 18.2864 9.10761 18.926 10.2934 19.2683C11.4791 19.6105 12.7327 19.6439 13.935 19.3654C15.1374 19.0869 16.2485 18.5056 17.163 17.6768C18.0775 16.848 18.7649 15.7992 19.16 14.63C19.1926 14.5362 19.2061 14.4368 19.1995 14.3377C19.1929 14.2386 19.1664 14.1418 19.1216 14.0532C19.0768 13.9645 19.0146 13.8858 18.9387 13.8217C18.8629 13.7576 18.7749 13.7094 18.68 13.68Z"
+          fill="#000000"/>
+</svg>

qcanvas/run.py

@@ -0,0 +1,29 @@
+import logging
+from logging import DEBUG, INFO, WARNING
+
+import qcanvas.app_start
+from qcanvas.util import logs, paths
+
+paths.data_storage().mkdir(parents=True, exist_ok=True)
+
+logging.basicConfig(
+    filename=paths.data_storage() / "debug.log",
+    level="WARN",
+)
+
+logs.set_levels(
+    {
+        "qcanvas": INFO,
+        "qcanvas.ui": WARNING,
+        "qcanvas_backend": INFO,
+        "qcanvas.ui.main_ui.status_bar_progress_display": DEBUG,
+    }
+)
+
+
+def main():
+    qcanvas.app_start.launch()
+
+
+if __name__ == '__main__':
+    main()

qcanvas/ui/course_viewer/__init__.py

@@ -0,0 +1,2 @@
+from .course_tree import CourseTree
+from .course_viewer import CourseViewer

qcanvas/ui/course_viewer/content_tree.py

@@ -0,0 +1,123 @@
+import logging
+from abc import abstractmethod
+from typing import *
+
+from qcanvas_backend.net.sync.sync_receipt import SyncReceipt
+from qtpy.QtCore import Signal, Slot
+from qtpy.QtWidgets import *
+
+from qcanvas.ui.memory_tree import MemoryTreeWidget, MemoryTreeWidgetItem
+from qcanvas.util.basic_fonts import bold_font, normal_font
+
+_logger = logging.getLogger(__name__)
+
+T = TypeVar("T")
+
+
+class ContentTree(MemoryTreeWidget, Generic[T]):
+    item_selected = Signal(object)
+
+    def __init__(
+        self,
+        tree_name: str,
+        *,
+        emit_selection_signal_for_type: Type,
+    ):
+        super().__init__(tree_name)
+        self._reloading = False
+        self._last_selected_id: Optional[str] = None
+        self._target_data_type = emit_selection_signal_for_type
+
+        self.selectionModel().selectionChanged.connect(self._selection_changed)
+
+    def ui_setup(
+        self,
+        *,
+        header_text: str | Sequence[str],
+        indentation: int = 20,
+        max_width: int,
+        min_width: int,
+    ) -> None:
+        if not isinstance(header_text, str) and isinstance(header_text, Sequence):
+            self.setHeaderLabels(header_text)
+        else:
+            self.setHeaderLabel(header_text)
+
+        self.setIndentation(indentation)
+        self.setMaximumWidth(max_width)
+        self.setMinimumWidth(min_width)
+
+    def reload(self, data: T, *, sync_receipt: Optional[SyncReceipt]) -> None:
+        self._reloading = True
+
+        try:
+            self.clear()
+            self.addTopLevelItems(self.create_tree_items(data, sync_receipt))
+            self.reexpand()
+        finally:
+            self._reloading = False
+
+        self.reselect()
+
+    def reselect(self) -> None:
+        if self._last_selected_id is not None:
+            if not self.select_ids([self._last_selected_id]):
+                self._clear_selection()
+
+    @abstractmethod
+    def create_tree_items(
+        self, data: T, sync_receipt: Optional[SyncReceipt]
+    ) -> Sequence[MemoryTreeWidgetItem]: ...
+
+    @Slot()
+    def _selection_changed(self) -> None:
+        if self._reloading:
+            return
+
+        if len(self.selectedItems()) > 0:
+            selected = self.selectedItems()[0]
+        else:
+            self._clear_selection()
+            return
+
+        if self.is_unseen(selected):
+            self.mark_as_seen(selected)
+
+        if not isinstance(selected, MemoryTreeWidgetItem):
+            self._clear_selection()
+            return
+
+        data = selected.extra_data
+
+        if isinstance(data, self._target_data_type):
+            if hasattr(data, "id"):
+                _logger.debug("id=%s selected", data.id)
+                self._last_selected_id = data.id
+                self.item_selected.emit(data)
+            else:
+                raise AttributeError(
+                    f"Expected {self._target_data_type.__name__} to have an id attribute"
+                )
+        else:
+            logging.warning(
+                "Expected type %s, got %s instead, ignoring",
+                self._target_data_type.__name__,
+                type(data).__name__,
+            )
+
+            self._clear_selection()
+
+    def _clear_selection(self) -> None:
+        _logger.debug("Clearing selection")
+
+        self._last_selected_id = None
+        self.item_selected.emit(None)
+
+    def is_unseen(self, item: QTreeWidgetItem) -> bool:
+        return item.font(0).bold()
+
+    def mark_as_unseen(self, item: QTreeWidgetItem) -> None:
+        item.setFont(0, bold_font)
+
+    def mark_as_seen(self, item: QTreeWidgetItem) -> None:
+        item.setFont(0, normal_font)

qcanvas/ui/course_viewer/course_tree.py

@@ -0,0 +1,93 @@
+import logging
+from typing import *
+
+import qcanvas_backend.database.types as db
+from qcanvas_backend.net.sync.sync_receipt import SyncReceipt
+from qtpy.QtCore import QObject, Qt, Signal, Slot
+
+from qcanvas.ui.course_viewer.content_tree import ContentTree
+from qcanvas.ui.memory_tree import MemoryTreeWidgetItem
+
+_logger = logging.getLogger(__name__)
+
+
+class _CourseTreeItem(MemoryTreeWidgetItem, QObject):
+    renamed = Signal(db.Course, str)
+
+    def __init__(self, course: db.Course):
+        MemoryTreeWidgetItem.__init__(
+            self,
+            id=course.id,
+            data=course,
+            strings=[course.configuration.nickname or course.name],
+        )
+        QObject.__init__(self)
+
+        self._course = course
+
+        self.setFlags(
+            Qt.ItemFlag.ItemIsEditable
+            | Qt.ItemFlag.ItemIsSelectable
+            | Qt.ItemFlag.ItemIsEnabled
+        )
+
+    def setData(self, column: int, role: int, value: Any):
+        if column != 0 or not isinstance(value, str):
+            return super().setData(column, role, value)
+
+        value = value.strip()
+
+        if len(value) == 0:
+            super().setData(column, role, self._course.name)
+            self.renamed.emit(self._course, None)
+        else:
+            super().setData(column, role, value)
+            self.renamed.emit(self._course, value)
+
+
+class CourseTree(ContentTree[Sequence[db.Term]]):
+    course_renamed = Signal(db.Course, str)
+
+    def __init__(self):
+        super().__init__("course_tree", emit_selection_signal_for_type=db.Course)
+
+        self.ui_setup(max_width=250, min_width=150, header_text="Courses")
+
+    def create_tree_items(
+        self, terms: List[db.Term], sync_receipt: Optional[SyncReceipt]
+    ) -> Sequence[MemoryTreeWidgetItem]:
+        widgets = []
+
+        for term in reversed(terms):
+            term_widget = self._create_term_widget(term)
+
+            for course in term.courses:
+                course_widget = self._create_course_widget(course, sync_receipt)
+                term_widget.addChild(course_widget)
+
+            widgets.append(term_widget)
+
+        return widgets
+
+    def _create_course_widget(
+        self, course: db.Course, sync_receipt: Optional[SyncReceipt]
+    ) -> MemoryTreeWidgetItem:
+        course_widget = _CourseTreeItem(course)
+        course_widget.renamed.connect(self._on_course_renamed)
+
+        is_new = sync_receipt is not None and course.id in sync_receipt.updated_courses
+
+        if is_new:
+            self.mark_as_unseen(course_widget)
+
+        return course_widget
+
+    def _create_term_widget(self, term: db.Term) -> MemoryTreeWidgetItem:
+        term_widget = MemoryTreeWidgetItem(id=term.id, data=term, strings=[term.name])
+        term_widget.setFlags(Qt.ItemFlag.ItemIsEnabled)
+
+        return term_widget
+
+    @Slot()
+    def _on_course_renamed(self, course: db.Course, new_name: str) -> None:
+        self.course_renamed.emit(course, new_name)

qcanvas/ui/course_viewer/course_viewer.py

@@ -0,0 +1,62 @@
+import logging
+from typing import Optional
+
+import qcanvas_backend.database.types as db
+from qcanvas_backend.net.resources.download.resource_manager import ResourceManager
+from qcanvas_backend.net.sync.sync_receipt import SyncReceipt
+from qtpy.QtWidgets import *
+
+from qcanvas.ui.course_viewer.tabs.assignment_tab import AssignmentTab
+from qcanvas.ui.course_viewer.tabs.mail_tab import MailTab
+from qcanvas.ui.course_viewer.tabs.page_tab import PageTab
+from qcanvas.util.basic_fonts import bold_font
+from qcanvas.util.layouts import layout
+from qcanvas.util.ui_tools import make_truncatable
+
+_logger = logging.getLogger(__name__)
+
+
+class CourseViewer(QWidget):
+    def __init__(
+        self,
+        course: db.Course,
+        downloader: ResourceManager,
+        *,
+        initial_sync_receipt: Optional[SyncReceipt] = None
+    ):
+        super().__init__()
+        # todo this is a mess. there are several other messes like this too, do they all have to be a mess?
+        self._course_label = QLabel(course.name)
+        self._course_label.setFont(bold_font)
+        make_truncatable(self._course_label)
+        self._pages_tab = PageTab.create_from_receipt(
+            course=course,
+            downloader=downloader,
+            sync_receipt=initial_sync_receipt,
+        )
+        self._assignments_tab = AssignmentTab.create_from_receipt(
+            course=course,
+            downloader=downloader,
+            sync_receipt=initial_sync_receipt,
+        )
+        self._mail_tab = MailTab.create_from_receipt(
+            course=course,
+            downloader=downloader,
+            sync_receipt=initial_sync_receipt,
+        )
+        self._tabs = QTabWidget()
+
+        self._tabs.addTab(self._pages_tab, "Pages")
+        self._tabs.addTab(self._assignments_tab, "Assignments")
+        self._tabs.addTab(self._mail_tab, "Mail")
+        # todo: move back to first when implemented
+        self._tabs.addTab(QLabel("Not implemented"), "Files")
+        # self._tabs.addTab(QLabel("Not implemented"), "Panopto") The meme lives on!
+
+        self.setLayout(layout(QVBoxLayout, self._course_label, self._tabs))
+
+    def reload(self, course: db.Course, *, sync_receipt: Optional[SyncReceipt]) -> None:
+        # self._tabs.setTabText(1, "*Pages")
+        self._pages_tab.reload(course, sync_receipt=sync_receipt)
+        self._assignments_tab.reload(course, sync_receipt=sync_receipt)
+        self._mail_tab.reload(course, sync_receipt=sync_receipt)

qcanvas/ui/course_viewer/tabs/__init__.py

@@ -0,0 +1,3 @@
+import logging
+
+_logger = logging.getLogger(__name__)

qcanvas/ui/course_viewer/tabs/assignment_tab/__init__.py

@@ -0,0 +1 @@
+from .assignment_tab import AssignmentTab

qcanvas/ui/course_viewer/tabs/assignment_tab/assignment_tab.py

@@ -0,0 +1,168 @@
+import logging
+from typing import *
+
+import qcanvas_backend.database.types as db
+from qcanvas_backend.net.resources.download.resource_manager import ResourceManager
+from qcanvas_backend.net.sync.sync_receipt import SyncReceipt
+from qtpy.QtWidgets import *
+
+from qcanvas.ui.course_viewer.tabs.assignment_tab.assignment_tree import AssignmentTree
+from qcanvas.ui.course_viewer.tabs.content_tab import ContentTab
+from qcanvas.ui.course_viewer.tabs.util import date_strftime_format
+from qcanvas.util.basic_fonts import bold_label
+from qcanvas.util.layouts import grid_layout
+
+_logger = logging.getLogger(__name__)
+
+
+class AssignmentTab(ContentTab):
+    @staticmethod
+    def create_from_receipt(
+        *,
+        course: db.Course,
+        sync_receipt: Optional[SyncReceipt],
+        downloader: ResourceManager,
+    ) -> "AssignmentTab":
+        return AssignmentTab(
+            course=course, sync_receipt=sync_receipt, downloader=downloader
+        )
+
+    def __init__(
+        self,
+        *,
+        course: db.Course,
+        sync_receipt: Optional[SyncReceipt],
+        downloader: ResourceManager,
+    ):
+        super().__init__(
+            explorer=AssignmentTree.create_from_receipt(
+                course, sync_receipt=sync_receipt
+            ),
+            title_placeholder_text="No assignment selected",
+            downloader=downloader,
+        )
+
+        self._due_date_label = QLabel("")
+        self._score_label = QLabel("")
+
+        self.enable_info_grid()
+
+    def setup_info_grid(self) -> QGridLayout:
+        grid = grid_layout(
+            [
+                [
+                    bold_label("Due:"),
+                    self._due_date_label,
+                ],
+                [
+                    bold_label("Score:"),
+                    self._score_label,
+                ],
+            ]
+        )
+
+        grid.setColumnStretch(0, 0)
+        grid.setColumnStretch(1, 1)
+
+        return grid
+
+    def update_info_grid(self, assignment: db.Assignment) -> None:
+        if assignment.due_date is not None:
+            due_text = assignment.due_date.strftime(date_strftime_format)
+        else:
+            due_text = "?"
+
+        self._due_date_label.setText(due_text)
+
+        self._score_label.setText(
+            f"{assignment.mark or '?'}/{assignment.max_mark_possible or '?'}"
+        )
+
+    # def __init__(
+    #     self,
+    #     course: db.Course,
+    #     resource_manager: ResourceManager,
+    #     *,
+    #     initial_sync_receipt: Optional[SyncReceipt] = None,
+    # ):
+    #     super().__init__()
+    #     self._assignment_tree = AssignmentTree(
+    #         course, sync_receipt=initial_sync_receipt
+    #     )
+    #     self._placeholder_assignment_title = "No assignment selected"
+    #     self._assignment_label = QLabel(self._placeholder_assignment_title)
+    #     self._assignment_label.setFont(bold_font)
+    #     self._due_date_label = QLabel("")
+    #     self._score_label = QLabel("")
+    #     self._info_grid = self._setup_info_grid()
+    #     make_truncatable(self._assignment_label)
+    #     self._viewer = ResourceRichBrowser(resource_manager)
+    #     self.setLayout(self._setup_layout())
+    #     self._assignment_tree.assignment_selected.connect(self._assignment_selected)
+    #     self._assignment_tree.reexpand()
+    #
+    # def _setup_info_grid(self) -> QWidget:
+    #     layout = grid_layout(
+    #         [
+    #             [
+    #                 _bold_label("Due:"),
+    #                 self._due_date_label,
+    #             ],
+    #             [
+    #                 _bold_label("Score:"),
+    #                 self._score_label,
+    #             ],
+    #         ]
+    #     )
+    #     layout.setColumnStretch(0, 0)
+    #     layout.setColumnStretch(1, 1)
+    #
+    #     widget = QWidget()
+    #     widget.setLayout(layout)
+    #
+    #     return widget
+    #
+    # def _setup_layout(self) -> QHBoxLayout:
+    #     h_box = QHBoxLayout()
+    #     h_box.addWidget(self._assignment_tree, 1)
+    #     h_box.addLayout(
+    #         layout(QVBoxLayout, self._assignment_label, self._info_grid, self._viewer),
+    #         2,
+    #     )
+    #
+    #     return h_box
+    #
+    # def reload(self, course: db.Course, *, sync_receipt: Optional[SyncReceipt]) -> None:
+    #     self._assignment_tree.reload(course, sync_receipt=sync_receipt)
+    #
+    # @Slot()
+    # def _assignment_selected(self, assignment: db.Assignment) -> None:
+    #     if assignment is not None:
+    #         _logger.debug(
+    #             "Show assignment %s (id='%s')", assignment.name, assignment.id
+    #         )
+    #         self._viewer.show_content(assignment)
+    #         self._update_info(assignment)
+    #     else:
+    #         self._assignment_label.setText(self._placeholder_assignment_title)
+    #         self._show_blank()
+    #
+    # def _update_info(self, assignment: db.Assignment) -> None:
+    #     _logger.debug(assignment.course.name)
+    #     _logger.debug("Due %s", assignment.due_date)
+    #     _logger.debug("Score %s/%s", assignment.mark, assignment.max_mark_possible)
+    #     self._assignment_label.setText(assignment.name)
+    #
+    #     if assignment.due_date is not None:
+    #         self._due_date_label.setText(
+    #             assignment.due_date.strftime("%A %Y-%m-%d %H:%M:%S")
+    #         )
+    #     else:
+    #         self._due_date_label.setText("?")
+    #     self._score_label.setText(
+    #         f"{assignment.mark or '?'}/{assignment.max_mark_possible or '?'}"
+    #     )
+    #
+    # def _show_blank(self) -> None:
+    #     self._viewer.show_blank()
+    #     self._info_grid.hide()

qcanvas/ui/course_viewer/tabs/assignment_tab/assignment_tree.py

@@ -0,0 +1,104 @@
+import logging
+from typing import Optional, Sequence
+
+import qcanvas_backend.database.types as db
+from qcanvas_backend.net.sync.sync_receipt import SyncReceipt
+from qtpy.QtGui import Qt
+from qtpy.QtWidgets import QHeaderView
+
+from qcanvas.ui.course_viewer.content_tree import ContentTree
+from qcanvas.ui.memory_tree import MemoryTreeWidgetItem
+
+_logger = logging.getLogger(__name__)
+
+
+class AssignmentTree(ContentTree[db.Course]):
+    @staticmethod
+    def create_from_receipt(
+        course: db.Course, *, sync_receipt: Optional[SyncReceipt]
+    ) -> "AssignmentTree":
+        tree = AssignmentTree(course.id)
+        tree.reload(course, sync_receipt=sync_receipt)
+        return tree
+
+    def __init__(self, course_id: str):
+        super().__init__(
+            tree_name=f"course.{course_id}.assignment_groups",
+            emit_selection_signal_for_type=db.Assignment,
+        )
+        self.ui_setup(
+            header_text=["Assignments", "Weight"],
+            indentation=15,
+            max_width=350,
+            min_width=150,
+        )
+
+        self._adjust_header()
+
+    def _adjust_header(self) -> None:
+        header = self.header()
+        header.setSectionResizeMode(0, QHeaderView.ResizeMode.Stretch)
+        header.setSectionResizeMode(1, QHeaderView.ResizeMode.ResizeToContents)
+        header.setStretchLastSection(False)
+
+    def create_tree_items(
+        self, course: db.Course, sync_receipt: Optional[SyncReceipt]
+    ) -> Sequence[MemoryTreeWidgetItem]:
+        widgets = []
+
+        for assignment_group in course.assignment_groups:  # type: db.AssignmentGroup
+            assignment_group_widget = self._create_assignment_group_widget(
+                assignment_group, sync_receipt
+            )
+
+            widgets.append(assignment_group_widget)
+            for assignment in assignment_group.assignments:  # type: db.Assignment
+                assignment_widget = self._create_assignment_widget(
+                    assignment, sync_receipt
+                )
+
+                assignment_group_widget.addChild(assignment_widget)
+
+        return widgets
+
+    def _create_assignment_group_widget(
+        self, assignment_group: db.AssignmentGroup, sync_receipt: SyncReceipt
+    ) -> MemoryTreeWidgetItem:
+        assignment_group_widget = MemoryTreeWidgetItem(
+            id=assignment_group.id,
+            data=assignment_group,
+            strings=[assignment_group.name, f"{assignment_group.group_weight}%"],
+        )
+
+        assignment_group_widget.setFlags(Qt.ItemFlag.ItemIsEnabled)
+
+        is_new = (
+            sync_receipt is not None
+            and assignment_group.id in sync_receipt.updated_assignment_groups
+        )
+
+        if is_new:
+            self.mark_as_unseen(assignment_group_widget)
+
+        return assignment_group_widget
+
+    def _create_assignment_widget(
+        self, assignment: db.Assignment, sync_receipt: SyncReceipt
+    ) -> MemoryTreeWidgetItem:
+        assignment_widget = MemoryTreeWidgetItem(
+            id=assignment.id, data=assignment, strings=[assignment.name]
+        )
+
+        assignment_widget.setFlags(
+            Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsSelectable
+        )
+
+        is_new = (
+            sync_receipt is not None
+            and assignment.id in sync_receipt.updated_assignments
+        )
+
+        if is_new:
+            self.mark_as_unseen(assignment_widget)
+
+        return assignment_widget