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

qcanvas/ui/setup/setup_dialog.py

@@ -0,0 +1,212 @@
+import logging
+from threading import Semaphore
+
+from qasync import asyncSlot
+from qcanvas_api_clients.canvas import CanvasClient, CanvasClientConfig
+from qcanvas_api_clients.panopto import PanoptoClient, PanoptoClientConfig
+from qcanvas_api_clients.util.request_exceptions import ConfigInvalidError
+from qtpy.QtCore import QUrl, Signal, Slot
+from qtpy.QtGui import QDesktopServices, QPixmap
+from qtpy.QtWidgets import *
+
+import qcanvas.util.settings as settings
+from qcanvas import icons
+from qcanvas.util import is_url
+from qcanvas.util.layouts import grid_layout_widget, layout
+
+_logger = logging.getLogger(__name__)
+
+_tutorial_url = (
+    "https://www.iorad.com/player/2053777/Canvas---How-to-generate-an-access-token-"
+)
+
+
+class SetupDialog(QDialog):
+    closed = Signal()
+
+    def __init__(self):
+        super().__init__()
+
+        self.setWindowTitle("Configure QCanvas")
+        self.setMinimumSize(550, 200)
+        self.resize(550, 200)
+        self.setWindowIcon(QPixmap(icons.main_icon))
+
+        self._semaphore = Semaphore()
+        self._canvas_url_box = QLineEdit(settings.client.canvas_url)
+        self._canvas_api_key_box = QLineEdit(settings.client.canvas_api_key)
+        self._canvas_api_key_box.setEchoMode(QLineEdit.EchoMode.Password)
+        self._panopto_url_box = QLineEdit(settings.client.panopto_url)
+        self._button_box = self._setup_button_box()
+        self._button_box.accepted.connect(self._accepted)
+        self._button_box.helpRequested.connect(self._help_requested)
+        self._waiting_indicator = self._setup_progress_bar()
+
+        self.setLayout(
+            layout(
+                QVBoxLayout,
+                grid_layout_widget(
+                    [
+                        [QLabel("Canvas URL"), self._canvas_url_box],
+                        [QLabel("Canvas API Key"), self._canvas_api_key_box],
+                        [QLabel("Panopto URL"), self._panopto_url_box],
+                    ]
+                ),
+                self._waiting_indicator,
+                self._button_box,
+            )
+        )
+
+    def _setup_button_box(self) -> QDialogButtonBox:
+        box = QDialogButtonBox()
+        box.addButton(QDialogButtonBox.StandardButton.Ok)
+        box.addButton("Get a canvas API key", QDialogButtonBox.ButtonRole.HelpRole)
+        return box
+
+    def _setup_progress_bar(self) -> QProgressBar:
+        progress = QProgressBar()
+        progress.setMaximum(0)
+        progress.setMinimum(0)
+        self._set_retain_size_when_hidden(progress)
+        progress.hide()
+        return progress
+
+    def _set_retain_size_when_hidden(self, widget: QWidget) -> None:
+        size_policy = widget.sizePolicy()
+        size_policy.setRetainSizeWhenHidden(True)
+        widget.setSizePolicy(size_policy)
+
+    # @Slot()
+    @asyncSlot()
+    async def _accepted(self) -> None:
+        if self._semaphore.acquire(False):
+            try:
+                self._clear_errors()
+                if self._check_inputs():
+                    return
+
+                self._waiting_indicator.setVisible(True)
+
+                canvas_config = CanvasClientConfig(
+                    api_token=self._canvas_api_key_box.text().strip(),
+                    canvas_url=self._get_url(self._canvas_url_box),
+                )
+
+                if not await self._check_canvas_config(canvas_config):
+                    return
+
+                if not await self._check_panopto_config(canvas_config):
+                    self._show_panopto_help()
+                    return
+
+            finally:
+                self._waiting_indicator.setVisible(False)
+                self._semaphore.release()
+
+            _logger.debug("Credentials are a-ok!")
+            self._save_and_close()
+        else:
+            _logger.debug("Validation already in progress")
+
+    def _clear_errors(self) -> None:
+        for line_edit in [
+            self._canvas_url_box,
+            self._panopto_url_box,
+            self._canvas_api_key_box,
+        ]:
+            line_edit.setStyleSheet(None)
+            line_edit.setToolTip(None)
+
+    def _check_inputs(self) -> bool:
+        had_error = False
+
+        if not is_url(self._get_url(self._canvas_url_box)):
+            had_error = True
+            self._show_error(self._canvas_url_box, "Canvas URL is invalid")
+        if len(self._canvas_api_key_box.text().strip()) == 0:
+            had_error = True
+            self._show_error(self._canvas_api_key_box, "Canvas API key is empty")
+        if not is_url(self._get_url(self._panopto_url_box)):
+            had_error = True
+            self._show_error(self._panopto_url_box, "Panopto URL is invalid")
+
+        return had_error
+
+    def _get_url(self, line_edit: QLineEdit) -> str:
+        url = line_edit.text().strip()
+
+        if not url.startswith("http"):
+            return "https://" + url
+        else:
+            return url
+
+    async def _check_canvas_config(self, canvas_config: CanvasClientConfig) -> bool:
+        try:
+            await CanvasClient.verify_config(canvas_config)
+            return True
+        except ConfigInvalidError:
+            self._show_error(self._canvas_api_key_box, "Canvas API key is invalid")
+            return False
+
+    def _show_error(self, line_edit: QLineEdit, text: str) -> None:
+        line_edit.setToolTip(text)
+        self._waiting_indicator.hide()
+        self._highlight_line_edit(line_edit)
+
+    def _highlight_line_edit(self, line_edit: QLineEdit) -> None:
+        line_edit.setStyleSheet("QLineEdit { border: 1px solid red }")
+
+    async def _check_panopto_config(self, canvas_config: CanvasClientConfig) -> bool:
+        client = CanvasClient(canvas_config)
+        try:
+            await PanoptoClient.verify_config(
+                PanoptoClientConfig(panopto_url=self._get_url(self._panopto_url_box)),
+                client,
+            )
+            return True
+        except ConfigInvalidError:
+            return False
+        finally:
+            await client.aclose()
+
+    def _show_panopto_help(self):
+        msg = QMessageBox(
+            QMessageBox.Icon.Information,
+            "Panopto Authentication",
+            "In order for QCanvas to use panopto, you need to link your panopto account to your canvas account. "
+            "A page will open in your web browser to do this when you click OK. It may ask you to sign into canvas.\n\n"
+            'Please tick "Remember my authorisation for this service" or QCanvas may not function correctly.\n\n'
+            "QCanvas can't access anything entered in your browser.",
+            QMessageBox.StandardButton.Ok,
+            self,
+        )
+        msg.accepted.connect(self._open_panopto_login)
+        msg.show()
+
+    @Slot()
+    def _open_panopto_login(self) -> None:
+        url = QUrl(self._get_url(self._panopto_url_box))
+        url.setPath("/Panopto/Pages/Auth/Login.aspx")
+        url.setQuery("instance=Canvas&AllowBounce=true")
+        QDesktopServices.openUrl(url)
+
+    def _save_and_close(self) -> None:
+        settings.client.canvas_url = self._get_url(self._canvas_url_box)
+        settings.client.panopto_url = self._get_url(self._panopto_url_box)
+        settings.client.canvas_api_key = self._canvas_api_key_box.text().strip()
+        self.closed.emit()
+        self.close()
+
+    @Slot()
+    def _help_requested(self) -> None:
+        msg = QMessageBox(
+            QMessageBox.Icon.Information,
+            "Help",
+            "An interactive tutorial will open in your browser when you click OK.\n\n"
+            'Note that the "purpose" text doesn\'t matter and you can enter anything you want.\n\n'
+            'You should also leave the "expires" item blank if you want the key to last forever.\n\n'
+            "Don't share this key. You can revoke it at any time.",
+            parent=self,
+        )
+        msg.accepted.connect(lambda: QDesktopServices.openUrl(_tutorial_url))
+        msg.show()

qcanvas/util/__init__.py

@@ -0,0 +1,2 @@
+# todo remove this
+from .url_checker import is_url

qcanvas/util/basic_fonts.py

@@ -0,0 +1,12 @@
+from qtpy.QtGui import QFont
+from qtpy.QtWidgets import QLabel
+
+normal_font = QFont()
+bold_font = QFont()
+bold_font.setBold(True)
+
+
+def bold_label(text: str) -> QLabel:
+    result = QLabel(text)
+    result.setFont(bold_font)
+    return result

qcanvas/util/fe_resource_manager.py

@@ -0,0 +1,23 @@
+import logging
+
+import qcanvas_backend.database.types as db
+from qcanvas_backend.net.resources.download.resource_manager import ResourceManager
+
+_logger = logging.getLogger(__name__)
+
+
+# todo stub for now
+class _RM(ResourceManager):
+    def on_download_progress(self, resource: db.Resource, current: int, total: int):
+        if total == 0 and current == 0:
+            _logger.info(f"download of {resource.file_name}: ?%")
+        else:
+            _logger.info(
+                f"download of {resource.file_name}: {(current / total) * 100}%"
+            )
+
+    def on_download_failed(self, resource: db.Resource):
+        _logger.info(f"download of {resource.file_name} failed")
+
+    def on_download_finished(self, resource: db.Resource):
+        _logger.info(f"download of {resource.file_name} finished")

qcanvas/util/html_cleaner.py

@@ -0,0 +1,25 @@
+import logging
+import re
+
+from bs4 import BeautifulSoup, ResultSet
+
+_logger = logging.getLogger(__name__)
+
+
+def clean_up_html(html: str) -> str:
+    html = re.sub(r"background-color:\s?initial;?", "", html)
+    html = html.replace(" ", " ")
+
+    doc = BeautifulSoup(html, "html.parser")
+
+    # Remove all scripts and css
+    _remove_tags(doc.find_all(["link", "script"]))
+    # Remove font awesome icons (which don't load anyway)
+    _remove_tags(doc.find_all(["span"], class_=["dp-icon-content"]))
+
+    return str(doc)
+
+
+def _remove_tags(tags: ResultSet) -> None:
+    for tag in tags:
+        tag.decompose()

qcanvas/util/layouts.py

@@ -0,0 +1,52 @@
+import logging
+from typing import *
+
+from qtpy.QtCore import Qt
+from qtpy.QtWidgets import *
+
+_logger = logging.getLogger(__name__)
+
+T = TypeVar("T")
+
+
+class GridItem(NamedTuple):
+    widget: QWidget
+    col_span: int = 1
+    row_span: int = 1
+    alignment: Qt.AlignmentFlag = Qt.AlignmentFlag.AlignLeft
+
+
+def layout_widget(layout_type: Type[T], *items: QWidget, **kwargs) -> QWidget:
+    widget = QWidget()
+    widget.setLayout(layout(layout_type, *items, **kwargs))
+    return widget
+
+
+def layout(layout_type: Type[T], *items: QWidget, **kwargs) -> T:
+    result_layout: QLayout = layout_type(**kwargs)
+
+    for item in items:
+        result_layout.addWidget(item)
+
+    return result_layout
+
+
+def grid_layout_widget(grid: Iterable[Iterable[QWidget | GridItem]]) -> QWidget:
+    widget = QWidget()
+    widget.setLayout(grid_layout(grid))
+    return widget
+
+
+def grid_layout(grid: Iterable[Iterable[QWidget | GridItem]]) -> QGridLayout:
+    result_layout = QGridLayout()
+
+    for row, row_list in enumerate(grid):
+        for col, item in enumerate(row_list):
+            if isinstance(item, GridItem):
+                result_layout.addWidget(
+                    item.widget, row, col, item.row_span, item.col_span, item.alignment
+                )
+            else:
+                result_layout.addWidget(item, row, col)
+
+    return result_layout

qcanvas/util/logs.py

@@ -0,0 +1,6 @@
+import logging
+
+
+def set_levels(levels: dict[str, int]) -> None:
+    for k, v in levels.items():
+        logging.getLogger(k).setLevel(v)

qcanvas/util/paths.py

@@ -0,0 +1,41 @@
+import logging
+import platform
+import sys
+from pathlib import Path
+
+import platformdirs
+from qtpy.QtCore import QDir, QSettings
+
+_logger = logging.getLogger(__name__)
+
+_is_running_on_windows = platform.system() == "Windows"
+_is_running_on_linux = platform.system() == "Linux"
+_is_running_as_pyinstaller = getattr(sys, "frozen", False) and hasattr(sys, "_MEIPASS")
+
+
+def client_settings() -> QSettings:
+    if _is_running_as_pyinstaller and _is_running_on_windows:
+        return QSettings(
+            str(Path(QDir.homePath()) / ".config" / "QCanvasTeam" / "canvas.ini"),
+            QSettings.Format.IniFormat,
+        )
+    else:
+        return QSettings("QCanvasTeam", "QCanvas")
+
+
+def root() -> Path:
+    root_path = Path()
+
+    if _is_running_as_pyinstaller:
+        root_path = platformdirs.user_data_path("QCanvasReborn", "QCanvasTeam")
+
+    _logger.debug("Root path %s", root_path.absolute())
+    return root_path
+
+
+def ui_storage() -> Path:
+    return root() / ".UI"
+
+
+def data_storage() -> Path:
+    return root() / ".DATA"

qcanvas/util/settings/__init__.py

@@ -0,0 +1,9 @@
+import logging
+
+from qcanvas.util.settings._client_settings import _ClientSettings
+from qcanvas.util.settings._ui_settings import _UISettings
+
+_logger = logging.getLogger(__name__)
+
+client = _ClientSettings()
+ui = _UISettings()

qcanvas/util/settings/_client_settings.py

@@ -0,0 +1,29 @@
+import logging
+from typing import *
+
+from qcanvas_api_clients.canvas import CanvasClientConfig
+from qcanvas_api_clients.panopto import PanoptoClientConfig
+
+from qcanvas.util import paths
+from qcanvas.util.settings._mapped_setting import BoolSetting, MappedSetting
+
+_logger = logging.getLogger(__name__)
+
+
+class _ClientSettings:
+    settings = paths.client_settings()
+    canvas_url: MappedSetting[Optional[str]] = MappedSetting(default=None)
+    canvas_api_key: MappedSetting[Optional[str]] = MappedSetting(default=None)
+    panopto_url: MappedSetting[Optional[str]] = MappedSetting(default=None)
+    quick_sync_enabled: BoolSetting = BoolSetting(default=False)
+    sync_on_start: BoolSetting = BoolSetting(default=False)
+
+    @property
+    def canvas_config(self) -> CanvasClientConfig:
+        return CanvasClientConfig(
+            api_token=self.canvas_api_key, canvas_url=self.canvas_url
+        )
+
+    @property
+    def panopto_config(self) -> PanoptoClientConfig:
+        return PanoptoClientConfig(panopto_url=self.panopto_url)

qcanvas/util/settings/_mapped_setting.py

@@ -0,0 +1,63 @@
+import logging
+from typing import *
+
+from qtpy.QtCore import QSettings
+
+_logger = logging.getLogger(__name__)
+
+
+class MappedSetting[T]:
+    """
+    Acts as a proxy for a named value in a QSettings object.
+    Stores the value in memory when initialised and updates it accordingly, to protect it from changes on disk.
+    """
+
+    def __init__(self, default: T | None = None):
+        self.settings_object: QSettings
+        self.default = default
+        self.value = None
+
+    def __get__(self, instance, owner) -> T:
+        return self.value
+
+    def __set__(self, instance, value) -> None:
+        self.value = value
+        self._write(value)
+
+    def __set_name__(self, owner, name) -> None:
+        if hasattr(owner, "settings") and isinstance(owner.settings, QSettings):
+            self.settings_object = owner.settings
+        else:
+            raise AttributeError(
+                "Expected owner object to have a 'settings' attribute of type QSettings"
+            )
+
+        self.setting_name = name
+        self.value = self._read()
+
+    def _read(self) -> object:
+        return self.settings_object.value(self.setting_name, self.default)
+
+    def _write(self, value: object) -> None:
+        self.settings_object.setValue(self.setting_name, value)
+
+
+class BoolSetting(MappedSetting[bool]):
+    def __init__(self, default: bool = False):
+        super().__init__(default)
+
+    @override
+    def _read(self) -> bool:
+        try:
+            # noinspection PyTypeChecker
+            value: str = super()._read()
+            return value.lower() == "true"
+        except:
+            return self.default
+
+    @override
+    def _write(self, value: object) -> None:
+        if not isinstance(value, bool):
+            raise TypeError()
+
+        super()._write(str(value).lower())

qcanvas/util/settings/_ui_settings.py

@@ -0,0 +1,34 @@
+import logging
+
+from qtpy.QtCore import QByteArray, QSettings
+
+from qcanvas.util.settings._mapped_setting import MappedSetting
+
+_logger = logging.getLogger(__name__)
+
+_default_theme = "auto"
+
+
+def ensure_theme_is_valid(theme: str) -> str:
+    if theme not in ["auto", "light", "dark", "native"]:
+        return _default_theme
+    else:
+        return theme
+
+
+class ThemeSetting(MappedSetting):
+    def __init__(self):
+        super().__init__(default=_default_theme)
+
+    def __get__(self, instance, owner):
+        return ensure_theme_is_valid(super().__get__(instance, owner))
+
+    def __set__(self, instance, value):
+        super().__set__(instance, ensure_theme_is_valid(value))
+
+
+class _UISettings:
+    settings = QSettings("QCanvasTeam", "QCanvas")
+    theme: ThemeSetting = ThemeSetting()
+    last_geometry: MappedSetting[QByteArray] = MappedSetting()
+    last_window_state: MappedSetting[QByteArray] = MappedSetting()

qcanvas/util/ui_tools.py

@@ -0,0 +1,41 @@
+import logging
+from typing import Any
+
+from qtpy.QtGui import QKeySequence
+from qtpy.QtWidgets import *
+
+_logger = logging.getLogger(__name__)
+
+
+def make_truncatable(widget: QWidget) -> None:
+    widget.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Fixed)
+
+
+def create_qaction(
+    *,
+    name: str,
+    shortcut: QKeySequence | None = None,
+    parent: QMenu = None,
+    triggered: Any = None,
+    checkable: bool | None = None,
+    checked: bool | None = None,
+) -> QAction:
+    action = QAction(name)
+
+    if shortcut is not None:
+        action.setShortcut(shortcut)
+
+    if parent is not None:
+        action.setParent(parent)
+        parent.addAction(action)
+
+    if triggered is not None:
+        action.triggered.connect(triggered)
+
+    if checkable is not None:
+        action.setCheckable(checkable)
+
+        if checked is not None:
+            action.setChecked(checked)
+
+    return action

qcanvas/util/url_checker.py

@@ -0,0 +1,13 @@
+import logging
+from urllib.parse import urlparse
+
+_logger = logging.getLogger(__name__)
+
+
+def is_url(url: str) -> bool:
+    # https://overflow.perennialte.ch/questions/7160737/how-to-validate-a-url-in-python-malformed-or-not#
+    try:
+        result = urlparse(url)
+        return all([result.scheme, result.netloc])
+    except ValueError:
+        return False

qcanvas-1.0.3.post0.dist-info/METADATA

@@ -0,0 +1,61 @@
+Metadata-Version: 2.1
+Name: qcanvas
+Version: 1.0.3.post0
+Summary: 
+Author: QCanvas
+Author-email: QCanvas@noreply.codeberg.org
+Requires-Python: >=3.12,<3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: aiosqlite (>=0.20.0,<0.21.0)
+Requires-Dist: asynctaskpool (>=0.2.1,<0.3.0)
+Requires-Dist: lightdb (>=2.0,<3.0)
+Requires-Dist: platformdirs (>=4.2.2,<5.0.0)
+Requires-Dist: pyinstaller (>=6.9.0,<7.0.0)
+Requires-Dist: pyqtdarktheme-fork (>=2.3.2,<3.0.0)
+Requires-Dist: qasync (>=0.27.1,<0.28.0)
+Requires-Dist: qcanvas-api-clients (>=0.2.2,<0.3.0)
+Requires-Dist: qcanvas-backend (==0.1.10a1)
+Requires-Dist: qtpy (>=2.4.1,<3.0.0)
+Requires-Dist: setuptools (==70.3.0)
+Requires-Dist: sqlalchemy (>=2.0.31,<3.0.0)
+Description-Content-Type: text/markdown
+
+# QCanvas
+
+QCanvas is a desktop client for Canvas LMS.
+
+# Downloads
+
+Download it from [releases](https://github.com/QCanvas/QCanvasApp/releases)
+
+# Development/Run from source
+
+## Prerequisites
+
+- Python 3.12+ (use [pyenv](https://github.com/pyenv/pyenv) if your distro does not have that version)
+- [Pipx](https://pipx.pypa.io/stable/) (optional)
+- Poetry (recommended to install using `pipx install poetry`)
+- [Appimagetool](https://github.com/AppImage/appimagetool) (Only for building the appimage)
+
+## Get started
+
+```bash
+git clone https://github.com/QCanvas/QCanvasApp.git
+cd QCanvasApp
+
+# Enter shell and run it
+poetry shell
+poetry install
+python qcanvas/run.py
+
+# Alternatively you can run it like this:
+poetry install
+poetry run python qcanvas/run.py
+```
+
+## Build custom AppImage
+
+```bash
+bash build_appimage.sh
+```