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

qcanvas/ui/course_viewer/tabs/content_tab.py

@@ -0,0 +1,96 @@
+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.content_tree import ContentTree
+from qcanvas.ui.course_viewer.tabs.resource_rich_browser import ResourceRichBrowser
+from qcanvas.util.basic_fonts import bold_font
+from qcanvas.util.ui_tools import make_truncatable
+
+_logger = logging.getLogger(__name__)
+
+
+class ContentTab(QWidget):
+    def __init__(
+        self,
+        *,
+        explorer: ContentTree[db.Course],
+        title_placeholder_text: str,
+        downloader: ResourceManager,
+    ):
+        super().__init__()
+        self._content_vbox = QVBoxLayout()
+        self._placeholder_text = title_placeholder_text
+        self._title_label = self._create_title_label()
+        self._info_grid: Optional[QWidget] = None
+        self._viewer = ResourceRichBrowser(downloader=downloader)
+        self._explorer = explorer
+
+        self._setup_layout()
+        self._explorer.item_selected.connect(self._item_selected)
+
+    def enable_info_grid(self) -> None:
+        # Info grid needs to be a widget, so it can be hidden/shown
+        grid_layout = self.setup_info_grid()
+
+        grid_widget = QWidget()
+        grid_widget.setLayout(grid_layout)
+        grid_widget.hide()
+
+        self._info_grid = grid_widget
+        self._content_vbox.insertWidget(1, grid_widget)
+
+    def _create_title_label(self) -> QLabel:
+        title_label = QLabel(self._placeholder_text)
+        title_label.setFont(bold_font)
+        make_truncatable(title_label)
+        return title_label
+
+    def setup_info_grid(self) -> QGridLayout:
+        """
+        Override this if you need an info grid
+        """
+        raise NotImplementedError()
+
+    def _setup_layout(self) -> None:
+        parent_layout = QHBoxLayout()
+        parent_layout.addWidget(self._explorer)
+
+        self._content_vbox.addWidget(self._title_label)
+        self._content_vbox.addWidget(self._viewer)
+
+        parent_layout.addLayout(self._content_vbox)
+
+        self.setLayout(parent_layout)
+
+    def reload(self, course: db.Course, *, sync_receipt: Optional[SyncReceipt]) -> None:
+        self._explorer.reload(course, sync_receipt=sync_receipt)
+
+    def _item_selected(self, item: object) -> None:
+        if isinstance(item, db.CourseContentItem):
+            _logger.debug("Show %s", item.name)
+            self._show_content(item)
+        else:
+            self._show_blank()
+
+    def _show_content(self, item: db.CourseContentItem) -> None:
+        self._title_label.setText(item.name)
+        self._viewer.show_content(item)
+
+        if self._info_grid is not None:
+            self._info_grid.show()
+            self.update_info_grid(item)
+
+    def update_info_grid(self, content: db.CourseContentItem) -> None:
+        raise NotImplementedError()
+
+    def _show_blank(self) -> None:
+        self._title_label.setText(self._placeholder_text)
+        self._viewer.show_blank(completely_blank=True)
+
+        if self._info_grid is not None:
+            self._info_grid.hide()

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

@@ -0,0 +1 @@
+from .mail_tab import MailTab

qcanvas/ui/course_viewer/tabs/mail_tab/mail_tab.py

@@ -0,0 +1,68 @@
+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.content_tab import ContentTab
+from qcanvas.ui.course_viewer.tabs.mail_tab.mail_tree import MailTree
+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__)
+
+
+# todo maybe update has_been_read? probably not the responsibility of this class though
+class MailTab(ContentTab):
+    @staticmethod
+    def create_from_receipt(
+        *,
+        course: db.Course,
+        sync_receipt: Optional[SyncReceipt],
+        downloader: ResourceManager,
+    ) -> "MailTab":
+        return MailTab(course=course, sync_receipt=sync_receipt, downloader=downloader)
+
+    def __init__(
+        self,
+        *,
+        course: db.Course,
+        sync_receipt: Optional[SyncReceipt],
+        downloader: ResourceManager,
+    ):
+        super().__init__(
+            explorer=MailTree.create_from_receipt(course, sync_receipt=sync_receipt),
+            title_placeholder_text="No mail selected",
+            downloader=downloader,
+        )
+
+        self._date_sent_label = QLabel("")
+        self._sender_label = QLabel("")
+
+        self.enable_info_grid()
+
+    def setup_info_grid(self) -> QGridLayout:
+        grid = grid_layout(
+            [
+                [
+                    bold_label("From:"),
+                    self._sender_label,
+                ],
+                [
+                    bold_label("Date:"),
+                    self._date_sent_label,
+                ],
+            ]
+        )
+
+        grid.setColumnStretch(0, 0)
+        grid.setColumnStretch(1, 1)
+
+        return grid
+
+    def update_info_grid(self, mail: db.CourseMessage) -> None:
+        self._date_sent_label.setText(mail.creation_date.strftime(date_strftime_format))
+        self._sender_label.setText(mail.sender_name)

qcanvas/ui/course_viewer/tabs/mail_tab/mail_tree.py

@@ -0,0 +1,70 @@
+import logging
+from typing import *
+
+import qcanvas_backend.database.types as db
+from qcanvas_backend.net.sync.sync_receipt import SyncReceipt
+from qtpy.QtWidgets import *
+
+from qcanvas.ui.course_viewer.content_tree import ContentTree
+from qcanvas.ui.memory_tree import MemoryTreeWidgetItem
+
+_logger = logging.getLogger(__name__)
+
+
+class MailTree(ContentTree[db.Course]):
+    @staticmethod
+    def create_from_receipt(
+        course: db.Course, *, sync_receipt: Optional[SyncReceipt]
+    ) -> "MailTree":
+        tree = MailTree(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}.mail",
+            emit_selection_signal_for_type=db.CourseMessage,
+        )
+        self.ui_setup(
+            header_text=["Subject", "Sender"],
+            max_width=500,
+            min_width=300,
+            indentation=20,
+        )
+
+        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 message in course.messages:  # type: db.CourseMessage
+            message_widget = self._create_mail_widget(message, sync_receipt)
+            widgets.append(message_widget)
+
+        return widgets
+
+    def _create_mail_widget(
+        self, message: db.CourseMessage, sync_receipt: Optional[SyncReceipt]
+    ) -> MemoryTreeWidgetItem:
+        message_widget = MemoryTreeWidgetItem(
+            id=message.id,
+            data=message,
+            strings=[message.name, message.sender_name],
+        )
+
+        is_new = (
+            sync_receipt is not None and message.id in sync_receipt.updated_messages
+        )
+
+        if is_new:
+            self.mark_as_unseen(message_widget)
+
+        return message_widget

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

@@ -0,0 +1 @@
+from .page_tab import PageTab

qcanvas/ui/course_viewer/tabs/page_tab/page_tab.py

@@ -0,0 +1,36 @@
+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 qcanvas.ui.course_viewer.tabs.content_tab import ContentTab
+from qcanvas.ui.course_viewer.tabs.page_tab.page_tree import PageTree
+
+_logger = logging.getLogger(__name__)
+
+
+class PageTab(ContentTab):
+
+    @staticmethod
+    def create_from_receipt(
+        *,
+        course: db.Course,
+        sync_receipt: Optional[SyncReceipt],
+        downloader: ResourceManager,
+    ) -> "PageTab":
+        return PageTab(course=course, sync_receipt=sync_receipt, downloader=downloader)
+
+    def __init__(
+        self,
+        *,
+        course: db.Course,
+        sync_receipt: Optional[SyncReceipt],
+        downloader: ResourceManager,
+    ):
+        super().__init__(
+            explorer=PageTree.create_from_receipt(course, sync_receipt=sync_receipt),
+            title_placeholder_text="No page selected",
+            downloader=downloader,
+        )

qcanvas/ui/course_viewer/tabs/page_tab/page_tree.py

@@ -0,0 +1,74 @@
+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 qcanvas.ui.course_viewer.content_tree import ContentTree
+from qcanvas.ui.memory_tree import MemoryTreeWidgetItem
+
+_logger = logging.getLogger(__name__)
+
+
+class PageTree(ContentTree[db.Course]):
+    @staticmethod
+    def create_from_receipt(
+        course: db.Course, *, sync_receipt: Optional[SyncReceipt]
+    ) -> "PageTree":
+        tree = PageTree(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}.modules",
+            emit_selection_signal_for_type=db.ModulePage,
+        )
+        self.ui_setup(
+            header_text="Content", indentation=15, max_width=300, min_width=150
+        )
+
+    def create_tree_items(
+        self, course: db.Course, sync_receipt: Optional[SyncReceipt]
+    ) -> Sequence[MemoryTreeWidgetItem]:
+        widgets = []
+
+        for module in course.modules:  # type: db.Module
+            module_widget = self._create_module_widget(module, sync_receipt)
+            widgets.append(module_widget)
+
+            for page in module.pages:  # type: db.ModulePage
+                page_widget = self._create_page_widget(page, sync_receipt)
+                module_widget.addChild(page_widget)
+
+        return widgets
+
+    def _create_module_widget(
+        self, module: db.Module, sync_receipt: Optional[SyncReceipt]
+    ) -> MemoryTreeWidgetItem:
+        module_widget = MemoryTreeWidgetItem(
+            id=module.id, data=module, strings=[module.name]
+        )
+        module_widget.setFlags(Qt.ItemFlag.ItemIsEnabled)
+
+        # todo add some helpers to SyncReceipt to make this less shit, and maybe use an empty syncreceipt instead of None
+        is_new = sync_receipt is not None and module.id in sync_receipt.updated_modules
+
+        if is_new:
+            self.mark_as_unseen(module_widget)
+
+        return module_widget
+
+    def _create_page_widget(
+        self, page: db.ModulePage, sync_receipt: Optional[SyncReceipt]
+    ) -> MemoryTreeWidgetItem:
+        page_widget = MemoryTreeWidgetItem(id=page.id, data=page, strings=[page.name])
+        page_widget.setFlags(Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsSelectable)
+
+        is_new = sync_receipt is not None and page.id in sync_receipt.updated_pages
+
+        if is_new:
+            self.mark_as_unseen(page_widget)
+
+        return page_widget

qcanvas/ui/course_viewer/tabs/resource_rich_browser.py

@@ -0,0 +1,176 @@
+import logging
+from typing import Optional
+
+import qcanvas_backend.database.types as db
+from bs4 import BeautifulSoup, Tag
+from qasync import asyncSlot
+from qcanvas_backend.net.resources.download.resource_manager import ResourceManager
+from qcanvas_backend.net.resources.extracting.no_extractor_error import NoExtractorError
+from qcanvas_backend.net.resources.scanning.resource_scanner import ResourceScanner
+from qtpy.QtCore import QUrl, Slot
+from qtpy.QtGui import QDesktopServices
+from qtpy.QtWidgets import QTextBrowser
+
+from qcanvas import icons
+from qcanvas.backend_connectors import FrontendResourceManager
+from qcanvas.util.html_cleaner import clean_up_html
+
+_logger = logging.getLogger(__name__)
+
+
+# class _DarkListener(QObject):
+#     theme_changed = Signal(str)
+#
+#     def __init__(self):
+#         super().__init__()
+#
+#         self._thread = threading.Thread(target=darkdetect.listener, args=(self._emit,))
+#         self._thread.daemon = True
+#         self._thread.start()
+#
+#     def _emit(self, theme: str) -> None:
+#         self.theme_changed.emit(theme)
+#
+# _dark_listener = _DarkListener()
+
+
+class ResourceRichBrowser(QTextBrowser):
+    def __init__(self, downloader: ResourceManager):
+        super().__init__()
+        self._downloader = downloader
+        self._content: Optional[db.CourseContentItem] = None
+        self._current_content_resources: dict[str, db.Resource] = {}
+        self._extractors = downloader.extractors
+        self.setMinimumWidth(300)
+        self.setOpenLinks(False)
+        self.anchorClicked.connect(self._open_url)
+
+        if isinstance(self._downloader, FrontendResourceManager):
+            self._downloader.download_finished.connect(self._download_updated)
+            self._downloader.download_failed.connect(self._download_updated)
+
+        # _dark_listener.theme_changed.connect(self._theme_changed)
+
+    # @Slot()
+    # def _theme_changed(self, theme: str) -> None:
+    #     print(theme)
+
+    def show_blank(self, completely_blank: bool = False) -> None:
+        if completely_blank:
+            self.clear()
+        else:
+            self.setPlainText("No content")
+
+        self._content = None
+        self._current_content_resources.clear()
+
+    def show_content(self, page: db.CourseContentItem) -> None:
+        if page.body is None:
+            self.show_blank()
+        else:
+            self._collect_resources(page)
+            self._show_page_content(page)
+
+    def _collect_resources(self, page: db.CourseContentItem):
+        self._current_content_resources = {
+            resource.id: resource for resource in page.resources
+        }
+
+    def _show_page_content(self, page: db.CourseContentItem):
+        self._content = page
+        html = clean_up_html(page.body)
+        html = self._substitute_links(html)
+        self.setHtml(html)
+
+    def _substitute_links(self, html: str) -> str:
+        doc = BeautifulSoup(html, "html.parser")
+
+        for resource_link in doc.find_all(self._extractors.tag_whitelist):
+            try:
+                extractor = self._extractors.extractor_for_tag(resource_link)
+                resource_id = extractor.resource_id_from_tag(resource_link)
+
+                # FIXME private method
+                if ResourceScanner._is_link_invisible(resource_link):
+                    _logger.debug("Found dead link for %s, removing", resource_id)
+                    resource_link.decompose()
+                    continue
+                elif resource_id not in self._current_content_resources:
+                    _logger.debug(
+                        "%s not found in page resources, ignoring", resource_id
+                    )
+                    continue
+
+                file_link_tag = self._create_resource_link_tag(doc, resource_id)
+                resource_link.replace_with(file_link_tag)
+            except NoExtractorError:
+                pass
+
+        return str(doc)
+
+    def _create_resource_link_tag(self, doc: BeautifulSoup, resource_id: str) -> Tag:
+        resource = self._current_content_resources[resource_id]
+
+        file_link_tag = doc.new_tag(
+            "a",
+            attrs={
+                "href": f"data:{resource_id}",
+            },
+        )
+
+        file_link_tag.append(self._file_icon_tag(doc, resource.download_state))
+        file_link_tag.append("\N{NO-BREAK SPACE}" + resource.file_name)
+
+        _logger.debug(str(file_link_tag))
+
+        return file_link_tag
+
+    def _file_icon_tag(
+        self, document: BeautifulSoup, download_state: db.ResourceDownloadState
+    ) -> Tag:
+        return document.new_tag(
+            "img",
+            attrs={
+                "src": self._download_state_icon(download_state),
+                "style": "vertical-align:middle",
+                "width": 18,
+            },
+        )
+
+    def _download_state_icon(self, download_state: db.ResourceDownloadState) -> str:
+        match download_state:
+            case db.ResourceDownloadState.DOWNLOADED:
+                return icons.file_downloaded
+            case db.ResourceDownloadState.NOT_DOWNLOADED:
+                return icons.file_not_downloaded
+            case db.ResourceDownloadState.FAILED:
+                return icons.file_download_failed
+            case _:
+                raise ValueError()
+
+    @asyncSlot()
+    async def _open_url(self, url: QUrl) -> None:
+        if url.scheme() == "data":
+            await self._open_resource_from_link(url)
+        else:
+            QDesktopServices.openUrl(url)
+
+    async def _open_resource_from_link(self, url) -> None:
+        resource_id = url.path()
+        resource = self._current_content_resources[resource_id]
+
+        try:
+            await self._downloader.download(resource)
+        except Exception as e:
+            _logger.warning(
+                "Download of resource id=%s failed", resource_id, exc_info=e
+            )
+            return
+
+        resource_path = self._downloader.resource_download_location(resource)
+        QDesktopServices.openUrl(QUrl.fromLocalFile(resource_path.absolute()))
+
+    @Slot()
+    def _download_updated(self, resource: db.Resource) -> None:
+        if self._content is not None and resource.id in self._current_content_resources:
+            self._show_page_content(self._content)

qcanvas/ui/course_viewer/tabs/util.py

@@ -0,0 +1 @@
+date_strftime_format = "%A, %Y-%m-%d, %H:%M:%S"

qcanvas/ui/main_ui/course_viewer_container.py

@@ -0,0 +1,52 @@
+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.QtCore import Qt
+from qtpy.QtWidgets import *
+
+from qcanvas.ui.course_viewer.course_viewer import CourseViewer
+
+_logger = logging.getLogger(__name__)
+
+
+class CourseViewerContainer(QStackedWidget):
+    def __init__(self, downloader: ResourceManager):
+        super().__init__()
+        self._course_viewers: dict[str, CourseViewer] = {}
+        self._downloader = downloader
+        self._last_course_id: Optional[str] = None
+        self._last_sync_receipt: Optional[SyncReceipt] = None
+        self._placeholder = QLabel("No Course Selected")
+        self._placeholder.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.addWidget(self._placeholder)
+
+    def show_blank(self) -> None:
+        self._last_course_id = None
+        self.setCurrentWidget(self._placeholder)
+
+    def load_course(self, course: db.Course) -> None:
+        if course.id not in self._course_viewers:
+            viewer = CourseViewer(
+                course=course,
+                downloader=self._downloader,
+                initial_sync_receipt=self._last_sync_receipt,
+            )
+            self._course_viewers[course.id] = viewer
+            self.addWidget(viewer)
+        else:
+            viewer = self._course_viewers[course.id]
+
+        self.setCurrentWidget(viewer)
+        self._last_course_id = course.id
+
+    async def reload_all(
+        self, courses: Sequence[db.Course], *, sync_receipt: Optional[SyncReceipt]
+    ) -> None:
+        self._last_sync_receipt = sync_receipt
+        for course in courses:
+            if course.id in self._course_viewers:
+                viewer = self._course_viewers[course.id]
+                viewer.reload(course, sync_receipt=sync_receipt)

qcanvas/ui/main_ui/options/__init__.py

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

qcanvas/ui/main_ui/options/quick_sync_option.py

@@ -0,0 +1,25 @@
+import logging
+from typing import *
+
+from qtpy.QtCore import Slot
+from qtpy.QtGui import QAction
+from qtpy.QtWidgets import QMenu
+
+from qcanvas.util import settings
+
+_logger = logging.getLogger(__name__)
+
+
+class QuickSyncOption(QAction):
+    def __init__(self, parent: Optional[QMenu] = None):
+        super().__init__("Ignore old courses", parent)
+        self.setToolTip(
+            "When this option is selected, old courses will not be synchronised. This will only effect the first sync."
+        )
+        self.setCheckable(True)
+        self.setChecked(settings.client.quick_sync_enabled)
+        self.triggered.connect(self._triggered)
+
+    @Slot()
+    def _triggered(self) -> None:
+        settings.client.quick_sync_enabled = self.isChecked()

qcanvas/ui/main_ui/options/sync_on_start_option.py

@@ -0,0 +1,25 @@
+import logging
+from typing import *
+
+from qtpy.QtCore import Slot
+from qtpy.QtGui import QAction
+from qtpy.QtWidgets import QMenu
+
+from qcanvas.util import settings
+
+_logger = logging.getLogger(__name__)
+
+
+class SyncOnStartOption(QAction):
+    def __init__(self, parent: Optional[QMenu] = None):
+        super().__init__("Sync on start", parent)
+        self.setToolTip(
+            "When this option is selected, synchronisation will be started automatically when the app starts."
+        )
+        self.setCheckable(True)
+        self.setChecked(settings.client.sync_on_start)
+        self.triggered.connect(self._triggered)
+
+    @Slot()
+    def _triggered(self) -> None:
+        settings.client.sync_on_start = self.isChecked()