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

qcanvas/ui/setup_dialog.py

@@ -1,190 +0,0 @@
-import traceback
-from threading import Semaphore
-from typing import Optional
-
-from PySide6.QtCore import Slot, QUrl
-from PySide6.QtGui import QDesktopServices
-from PySide6.QtWidgets import QDialog, QWidget, QHBoxLayout, QLabel, QLineEdit, QVBoxLayout, \
-    QDialogButtonBox, QGridLayout, QMessageBox
-from PySide6.QtWidgets import QProgressBar
-from qasync import asyncSlot
-
-from qcanvas.net.canvas import CanvasClient
-from qcanvas.util.app_settings import settings
-
-tutorial_url = "https://www.iorad.com/player/2053777/Canvas---How-to-generate-an-access-token-"
-
-
-def row(name: str) -> QWidget:
-    widget = QWidget()
-    layout = QHBoxLayout()
-
-    layout.addWidget(QLabel(name))
-    layout.addWidget(QLineEdit())
-
-    widget.setLayout(layout)
-
-    return widget
-
-
-class SetupDialog(QDialog):
-    """
-    The dialog shown to the user when the canvas api key/url is invalid, such as the first time the user is opening the application.
-    The dialog asks for an api key and canvas url then verifies them before saving them to the primary app settings file.
-    """
-    def __init__(self, parent: Optional[QWidget] = None, allow_cancel: bool = True):
-        super().__init__(parent)
-
-        self.setWindowTitle("Setup")
-        self._row_counter = 0
-        self._operation_sem = Semaphore()
-        self.allow_cancel = allow_cancel
-
-        # Progress bar used to indicate that an operation is underway and the application has not frozen
-        self.operation_activity_indicator = QProgressBar()
-        self.operation_activity_indicator.setMaximum(0)
-        self.operation_activity_indicator.setMinimum(0)
-        self.operation_activity_indicator.setValue(0)
-        self.operation_activity_indicator.hide()
-
-        self.grid = QGridLayout()
-
-        # Line edits for the different properties
-        self.canvas_url = QLineEdit(settings.canvas_url or "")
-        self.panopto_url = QLineEdit()
-        self.canvas_api_key = QLineEdit(settings.api_key or "")
-
-        # Add the line edits to the dialog
-        self._row("Canvas URL", self.canvas_url)
-        self._row("Painopto URL", self.panopto_url)
-        self._row("Canvas API key", self.canvas_api_key)
-
-        # Add the activity indicator to the dialog
-        self.grid.addWidget(self.operation_activity_indicator, self._row_counter, 0, 1, 2)
-
-        # Setup the rest of the layout
-        grid_widget = QWidget()
-        grid_widget.setLayout(self.grid)
-
-        stack = QVBoxLayout()
-        stack.addWidget(grid_widget)
-        stack.addWidget(self._setup_button_box())
-
-        self.setLayout(stack)
-        self.resize(500, 200)
-
-    def _setup_button_box(self) -> QDialogButtonBox:
-        button_box = QDialogButtonBox(
-            QDialogButtonBox.StandardButton.Save | QDialogButtonBox.StandardButton.Cancel if self.allow_cancel else QDialogButtonBox.StandardButton.Save)
-        # Add a help button to show the user how to get a canvas api key
-        button_box.addButton("How to get a canvas API key?", QDialogButtonBox.ButtonRole.HelpRole)
-        # Connect signals
-        button_box.helpRequested.connect(self._show_help)
-        button_box.accepted.connect(self._verify)
-        button_box.rejected.connect(lambda: self.reject())
-
-        return button_box
-
-    @asyncSlot()
-    async def _verify(self) -> None:
-        """
-        Verifies the user's inputs before saving them
-        """
-        if self._operation_sem.acquire(False):
-            try:
-                canvas_url_text = self.ensure_protocol(self.canvas_url.text().strip())
-                panopto_url_text = self.ensure_protocol(self.panopto_url.text().strip())
-                canvas_api_key_text = self.canvas_api_key.text().strip()
-
-                if not (len(canvas_url_text) > 0 and QUrl(canvas_url_text).isValid()):
-                    self._show_invalid_msgbox("Canvas URL")
-                    return
-                if not (len(panopto_url_text) > 0 and QUrl(panopto_url_text).isValid()):
-                    self._show_invalid_msgbox("Panopto URL")
-                    return
-                elif not len(canvas_api_key_text) > 0:
-                    self._show_invalid_msgbox("API key")
-                elif not (await self._verify_canvas_config(canvas_url_text, canvas_api_key_text)):
-                    # Show message box saying that either the url or api key is incorrect
-                    QMessageBox(
-                        QMessageBox.Icon.Critical,
-                        "Error",
-                        f"The canvas URL or API key is invalid.\nPlease check you entered them correctly.",
-                        parent=self
-                    ).show()
-                else:
-                    # If nothing was wrong, everything should be fine
-                    # Save the url and api key
-                    settings.canvas_url = canvas_url_text
-                    settings.panopto_url = panopto_url_text
-                    settings.api_key = canvas_api_key_text
-
-                    self.accept()
-            finally:
-                self._operation_sem.release()
-        else:
-            QMessageBox(QMessageBox.Icon.Critical, "Error", "An operation is already in progress", parent=self).show()
-
-    def _show_invalid_msgbox(self, field_name: str) -> None:
-        """
-        Shows a message box saying that that specified field is invalid
-        """
-        QMessageBox(
-            QMessageBox.Icon.Critical,
-            "Error",
-            f"{field_name} is invalid",
-            parent=self
-        ).show()
-
-    @staticmethod
-    def ensure_protocol(url: str) -> str:
-        # Check if the url is blank/empty so we can tell if the user didn't input anything
-        if len(url) > 0 and not (url.startswith("http://") or url.startswith("https://")):
-            return "https://" + url
-        else:
-            return url
-
-    async def _verify_canvas_config(self, canvas_url: str, api_key: str) -> bool:
-        """
-        Makes a network request to canvas to ensure the provided url and api key are correct
-
-        Returns
-        -------
-        bool
-            True if valid, False if invalid
-        """
-        self.operation_activity_indicator.show()
-
-        try:
-            return await CanvasClient.verify_config(canvas_url, api_key)
-        except:
-            traceback.print_exc()
-            return False
-        finally:
-            self.operation_activity_indicator.hide()
-
-    @Slot()
-    def _show_help(self) -> None:
-        msg = QMessageBox(
-            QMessageBox.Icon.Information,
-            "Help",
-            """An interactive tutorial will open in your browser when you click OK.
-            
-Note that the "purpose" text doesn't matter and you can enter anything you want.
-
-You should also leave the "expires" item blank if you want the key to last forever.
-
-Don't share this key. You can revoke it at any time.""",
-            parent=self
-        )
-        msg.accepted.connect(lambda: QDesktopServices.openUrl(tutorial_url))
-        msg.show()
-
-    def _row(self, name: str, widget: QWidget) -> None:
-        """
-        Shortcut to add a field with a label to the dialog
-        """
-        self.grid.addWidget(QLabel(name), self._row_counter, 0)
-        self.grid.addWidget(widget, self._row_counter, 1)
-
-        self._row_counter += 1

qcanvas/ui/status_bar_reporter.py

@@ -1,40 +0,0 @@
-from typing import Any
-
-from PySide6.QtWidgets import QStatusBar, QProgressBar
-
-from qcanvas.util.progress_reporter import ProgressReporter
-
-
-class StatusBarReporter(ProgressReporter):
-    def __init__(self, status_bar: QStatusBar):
-        self.status_bar = status_bar
-        self.section_name: None | str = None
-        self.progress_bar: QProgressBar | None = None
-
-    def section_started(self, section_name: str, total_progress: int) -> None:
-        self.section_name = section_name
-        self.status_bar.showMessage(section_name)
-
-        if self.progress_bar is None:
-            self.progress_bar = QProgressBar(self.status_bar)
-            self.progress_bar.setMaximumHeight(self.status_bar.height())
-            self.progress_bar.setMinimum(0)
-            self.status_bar.addPermanentWidget(self.progress_bar)
-
-        self.progress_bar.setValue(0)
-        self.progress_bar.setMaximum(total_progress)
-
-    def progress(self, current_progress: int, total: int) -> None:
-        if self.progress_bar is not None:
-            self.progress_bar.setValue(current_progress)
-
-    def finished(self) -> None:
-        self.status_bar.removeWidget(self.progress_bar)
-        self.progress_bar = None
-        self.status_bar.showMessage("Finished", 5000)
-
-    def errored(self, context: Any) -> None:
-        if self.status_bar.parent() is not None:
-            self.status_bar.removeWidget(self.progress_bar)
-            self.progress_bar = None
-            self.status_bar.showMessage("Synchronisation error!!", 5000)

qcanvas/ui/viewer/course_list.py

@@ -1,96 +0,0 @@
-from datetime import datetime
-from typing import Sequence
-
-from PySide6.QtCore import QItemSelection, Slot, Signal, QObject
-from PySide6.QtGui import QStandardItemModel, QStandardItem
-from PySide6.QtWidgets import QTreeView
-from qasync import asyncSlot
-
-import qcanvas.db as db
-from qcanvas.util.course_indexer import DataManager
-
-
-class CourseNode(QStandardItem, QObject):
-    name_changed = Signal(db.Course, str)
-
-    def __init__(self, course: db.Course):
-        QObject.__init__(self)
-        QStandardItem.__init__(self, course.preferences.local_name or course.name)
-        self.course = course
-
-    def setData(self, value, role=...):
-        if isinstance(value, str):
-            value = value.strip()
-
-            if len(value) == 0:
-                super().setData(self.course.name, role)
-                self.name_changed.emit(self.course, None)
-            else:
-                super().setData(value, role)
-                self.name_changed.emit(self.course, value)
-        else:
-            super().setData(value, role)
-
-
-class CourseList(QTreeView):
-    course_selected = Signal(db.Course)
-
-    def __init__(self, data_manager: DataManager):
-        super().__init__()
-        self.data_manager = data_manager
-        self.model = QStandardItemModel()
-        self.setModel(self.model)
-        self.selectionModel().selectionChanged.connect(self._on_selection_changed)
-
-    @asyncSlot(db.Course, str)
-    async def course_name_changed(self, course: db.Course, name: str):
-        course.preferences.local_name = name
-        await self.data_manager.update_item(course.preferences)
-
-    def load_course_list(self, courses: Sequence[db.Course]):
-        self.model.clear()
-        self.model.setHorizontalHeaderLabels(["Canvas Courses"])
-
-        courses_root = self.model.invisibleRootItem()
-
-        for term, courses in self.group_courses_by_term(courses):
-            term_node = QStandardItem(term.name)
-            term_node.setEditable(False)
-            term_node.setSelectable(False)
-
-            for course in courses:
-                course_node = CourseNode(course)
-                course_node.name_changed.connect(self.course_name_changed)
-                term_node.appendRow(course_node)
-
-            courses_root.appendRow(term_node)
-
-        self.expandAll()
-
-    @staticmethod
-    def group_courses_by_term(courses: Sequence[db.Course]):
-        courses_grouped_by_term: dict[db.Term, list[db.Course]] = {}
-
-        # Put courses into groups in the above dict
-        for course in courses:
-            if course.term in courses_grouped_by_term:
-                courses_grouped_by_term[course.term].append(course)
-            else:
-                courses_grouped_by_term[course.term] = [course]
-
-        # Convert the dict item list into a mutable list
-        pairs = list(courses_grouped_by_term.items())
-        # Sort them by start date, with most recent terms at the start
-        pairs.sort(key=lambda x: x[0].start_at or datetime.min, reverse=True)
-
-        return pairs
-
-    @Slot(QItemSelection, QItemSelection)
-    def _on_selection_changed(self, selected: QItemSelection, deselected: QItemSelection):
-        if len(self.selectedIndexes()) == 0:
-            self.course_selected.emit(None)
-        else:
-            item = self.model.itemFromIndex(self.selectedIndexes()[0])
-
-            if isinstance(item, CourseNode):
-                self.course_selected.emit(item.course)

qcanvas/ui/viewer/file_list.py

@@ -1,195 +0,0 @@
-from typing import Sequence
-
-from PySide6.QtCore import QObject, Slot, Qt
-from PySide6.QtWidgets import QStyledItemDelegate, QStyleOptionProgressBar, QApplication, QStyle, \
-    QHeaderView, QStyleOptionViewItem, QTreeWidget, QTreeWidgetItem
-
-import qcanvas.db.database as db
-from qcanvas.util.download_pool import DownloadPool
-from qcanvas.util.helpers import file_icon_helper
-
-
-# https://code.whatever.social/questions/1094841/get-human-readable-version-of-file-size#1094933
-def sizeof_fmt(num, suffix="B"):
-    for unit in ("", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi"):
-        if abs(num) < 1024.0:
-            return f"{num:3.1f}{unit}{suffix}"
-        num /= 1024.0
-    return f"{num:.1f}Yi{suffix}"
-
-
-class FileColumnDelegate(QStyledItemDelegate):
-    def __init__(self, tree: QTreeWidget, download_pool: DownloadPool, parent, *args, **kwargs):
-        super().__init__(parent, *args, **kwargs)
-        self.download_pool = download_pool
-        self.tree = tree
-
-    def paint(self, painter, option, index) -> None:
-        item = self.tree.itemFromIndex(index)
-
-        # Check that the item is actually a file row and not already downloaded
-        if not isinstance(item, FileRow) or item.resource.state == db.ResourceState.DOWNLOADED:
-            return super().paint(painter, option, index)
-
-        resource = item.resource
-        progress = item.download_progres
-
-        if progress == resource.file_size:
-            return super().paint(painter, option, index)
-
-        # Check that the file is not currently downloading (signaled by progress = -1)
-        if progress < 0:
-            # Show the state of the file instead (downloaded, failed, not downloaded)
-            view_item = QStyleOptionViewItem(option)
-            self.initStyleOption(view_item, index)
-            view_item.text = db.ResourceState.human_readable(resource.state)
-
-            return QApplication.style().drawControl(QStyle.CE_ItemViewItem, view_item, painter, view_item.widget)
-        else:
-            # otherwise show progress bar
-            progress_bar = QStyleOptionProgressBar()
-            progress_bar.rect = option.rect
-            progress_bar.minimum = 0
-            progress_bar.maximum = resource.file_size
-            progress_bar.progress = progress
-            # Display download progress as a percentage
-            progress_bar.text = "{0:.0f}%".format((progress / resource.file_size) * 100)
-            progress_bar.textVisible = True
-
-            QApplication.style().drawControl(QStyle.CE_ProgressBar, progress_bar, painter)
-
-
-class FileRow(QTreeWidgetItem):
-    def __init__(self, resource: db.Resource):
-        # Set column names
-        super().__init__(
-            [
-                resource.file_name,
-                resource.date_discovered.strftime("%Y-%m-%d"),
-                sizeof_fmt(resource.file_size),
-            ]
-        )
-
-        # Set the icon for this file, displayed in the name column
-        self.setIcon(0, file_icon_helper.icon_for_filename(resource.file_name))
-
-        self.resource = resource
-        # This is used to pass the download progress value from download_progress_updated to FileColumnDelegate. This way
-        # it means we don't have to get the download progress from the DownloadPool a second time with an async function
-        # (which is undesirable from an item delegate...). Use -1 to show that the file is not currently downloading.
-        self.download_progres = -1
-
-
-class FileList(QTreeWidget):
-    def __init__(self, download_pool: DownloadPool, parent: QObject | None = None):
-        super().__init__(parent)
-        self._setup_header()
-
-        # Keep a map of file ids to rows, so we can actually update the download column using a file id.
-        # This has to be a list or else files that are in multiple modules/pages will not be updated properly on the tree
-        self.row_id_map: dict[str, list[FileRow]] = {}
-        self.download_pool = download_pool
-        self.setAlternatingRowColors(True)
-        # Add the download column renderer
-        self.setItemDelegateForColumn(3, FileColumnDelegate(tree=self, download_pool=download_pool, parent=None))
-
-        # Connect download update events
-        self.download_pool.download_progress_updated.connect(self._file_download_progress_update)
-        self.download_pool.download_failed.connect(self._file_download_failed_update)
-
-    @Slot(str, int)
-    def _file_download_progress_update(self, resource_id: str, progress: int):
-        # Ignore files that aren't in this tree
-        if resource_id not in self.row_id_map:
-            return
-
-        rows = self.row_id_map[resource_id]
-
-        # Update each row that maps to this file.
-        # Note that a file may belong to multiple modules or pages
-        for row in rows:
-            # Update the progress
-            row.download_progres = progress
-
-            # Get the download column for the relevant item
-            index = self.indexFromItem(row, 3)
-
-            # Update the download column
-            self.model().dataChanged.emit(index, index, Qt.ItemDataRole.DisplayRole)
-
-    @Slot(str)
-    def _file_download_failed_update(self, resource_id: str):
-        if resource_id not in self.row_id_map:
-            return
-
-        rows = self.row_id_map[resource_id]
-
-        for row in rows:
-            # Get the download column for the relevant item
-            index = self.indexFromItem(row, 3)
-
-            # Update the download column
-            self.model().dataChanged.emit(index, index, Qt.ItemDataRole.DisplayRole)
-
-    def _setup_header(self):
-        self.setColumnCount(4)
-        self.setHeaderLabels(["Name", "Date Found", "Size", "Download"])
-
-        header = self.header()
-        header.setSectionResizeMode(0, QHeaderView.ResizeMode.Stretch)
-        header.setSectionResizeMode(1, QHeaderView.ResizeMode.ResizeToContents)
-        header.setSectionResizeMode(2, QHeaderView.ResizeMode.ResizeToContents)
-        # Make the download progress column not try to take up all remaining space in the tree, as it just looks weird
-        # and decreases room for more important data
-        header.setStretchLastSection(0)
-
-    def load_items(self, items: Sequence[db.ModuleItem | db.Module]):
-        self.clear()
-
-        groups = []
-
-        for item in items:
-            # Get the resources depending on the type of the item
-            if isinstance(item, (db.PageLike, db.ModuleItem)):
-                resources = item.resources
-            elif isinstance(item, db.Module):
-                resources = []
-
-                for module_item in item.items:
-                    resources.extend(module_item.resources)
-            else:
-                continue
-
-            # Avoid adding groups with no files in them, it just adds clutter
-            if len(resources) == 0:
-                continue
-
-            # Create the group node for this item
-            group_node = QTreeWidgetItem([item.name])
-
-            # fixme this does not remove duplicate files e.g. when on module groups
-
-            for resource in resources:
-                row = FileRow(resource)
-
-                # Put the file into the row id map so we can use the file id provided by download_progress_updated
-                # and such to update the download progress in the tree
-                if resource.id not in self.row_id_map:
-                    self.row_id_map[resource.id] = [row]
-                else:
-                    self.row_id_map[resource.id].append(row)
-
-                # Add the row to the group
-                group_node.addChild(row)
-
-            # Add the module/page to the list
-            groups.append(group_node)
-
-        # Add all the items and expand them
-        self.insertTopLevelItems(0, groups)
-        self.expandAll()
-
-    def clear(self):
-        super().clear()
-        self._setup_header()
-        self.row_id_map.clear()

qcanvas/ui/viewer/file_view_tab.py

@@ -1,62 +0,0 @@
-from typing import Sequence
-
-from PySide6.QtWidgets import *  # QWidget, QTreeView, QGroupBox, QBoxLayout, QHeaderView, QHBoxLayout, QComboBox, QLabel
-
-import qcanvas.db as db
-from qcanvas.ui.viewer.file_list import FileList
-from qcanvas.util.constants import default_assignments_module_names
-from qcanvas.util.download_pool import DownloadPool
-
-
-class FileColumn(QGroupBox):
-    def __init__(self, column_name, download_pool: DownloadPool):
-        super().__init__(title=column_name)
-
-        self.tree = FileList(download_pool)
-        self.setLayout(QBoxLayout(QBoxLayout.Direction.TopToBottom))
-        self.layout().addWidget(self.tree)
-
-    def load_items(self, items: Sequence[db.ModuleItem | db.Module]):
-        self.tree.load_items(items)
-
-    def clear(self):
-        self.tree.clear()
-
-
-class FileViewTab(QWidget):
-
-    def __init__(self, download_pool: DownloadPool):
-        super().__init__()
-
-        self.files_column = FileColumn("Files", download_pool)
-        self.assignment_files_column = FileColumn("Assignment files", download_pool)
-
-        layout = QHBoxLayout()
-        layout.addWidget(self.files_column)
-        layout.addWidget(self.assignment_files_column)
-
-        self.setLayout(layout)
-
-    def load_course_files(self, course: db.Course):
-        module_items: list[db.ModuleItem] = []
-        assignment_items: list[db.ModuleItem] = []
-
-        for module_item in course.module_items:
-            if module_item.module.name.lower() in default_assignments_module_names:
-                assignment_items.append(module_item)
-            else:
-                module_items.append(module_item)
-
-        if course.preferences.files_group_by_preference == db.GroupByPreference.GROUP_BY_MODULES:
-            exclude_assignments_module = list(
-                filter(lambda x: x.name.lower() not in default_assignments_module_names, course.modules))
-
-            self.files_column.load_items(exclude_assignments_module)
-        else:
-            self.files_column.load_items(module_items)
-
-        self.assignment_files_column.load_items(assignment_items + course.assignments)
-
-    def clear(self):
-        self.files_column.clear()
-        self.assignment_files_column.clear()