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

qcanvas/util/helpers/canvas_sanitiser.py

@@ -1,47 +0,0 @@
-"""
-I dedicate this file to removing the random crap canvas puts in its data.
-Like random NBSPs. Gotta love those fuckers.
-Thanks instructure btw for you state of the art WYSIWYG dogshit editor.
-"""
-from bs4 import BeautifulSoup
-
-NBSP = " "
-
-
-def remove_garbage_from_title(smelly_canvas_title: str) -> str:
-    """
-    Removes trailing tabs, spaces and NBSPs from smelly canvas titles.
-    Parameters
-    ----------
-    smelly_canvas_title
-
-    Returns
-    -------
-    str
-        Clean title that is not smelly and has no NBSPs.
-    """
-    return (smelly_canvas_title
-            .strip(f"\t {NBSP}")  # remove trailing garbage
-            .replace(NBSP, " ")  # remove any other NBSPs
-            )
-
-
-def remove_stylesheets_from_html(smelly_html: str) -> str:
-    """
-    Removes all stylesheet links from `smelly_html`.
-
-    Parameters
-    ----------
-    smelly_html
-        The html to remove style sheets from
-    Returns
-    -------
-        The non-smelly html with all stylesheet links removed
-    """
-    bs = BeautifulSoup(smelly_html, "html.parser")
-
-    # remove links
-    for ele in bs.find_all("link", {"rel": "stylesheet"}):
-        ele.decompose()
-
-    return str(bs)

qcanvas/util/helpers/file_icon_helper.py

@@ -1,34 +0,0 @@
-from PySide6.QtCore import QMimeDatabase
-from PySide6.QtGui import QIcon
-from PySide6.QtWidgets import QApplication, QStyle
-
-_mime_database = QMimeDatabase()
-_default_icon = None
-
-
-def icon_for_filename(file_name: str) -> QIcon:
-    """
-    Gets the icon for a filename, based on its extension
-    Parameters
-    ----------
-    file_name
-        The name of the file
-    Returns
-    -------
-    QIcon
-        The icon for the file
-    """
-    global _default_icon
-
-    for mime_type in _mime_database.mimeTypesForFileName(file_name):
-        icon = QIcon.fromTheme(mime_type.iconName())
-
-        # Return the appropriate icon if it's found
-        if not icon.isNull():
-            return icon
-
-    # Cache the default icon, used when the icon for a file is unknown/not found
-    if _default_icon is None:
-        _default_icon = QApplication.style().standardIcon(QStyle.StandardPixmap.SP_FileIcon)
-
-    return _default_icon

qcanvas/util/helpers/qaction_helper.py

@@ -1,25 +0,0 @@
-from typing import Any
-
-from PySide6.QtGui import QAction, QKeySequence
-
-
-def create_qaction(name: str, shortcut: QKeySequence | None = None, parent: Any = 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)
-
-    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/helpers/theme_helper.py

@@ -1,48 +0,0 @@
-from datetime import datetime
-
-import qdarktheme
-
-from qcanvas.util.app_settings import settings
-
-
-def apply_selected_theme() -> None:
-    """
-    Applies the selected theme from the app's settings
-    """
-    if settings.theme != "native":
-        qdarktheme.setup_theme(
-            settings.theme,
-            custom_colors=_get_colours()
-        )
-
-
-red_theme = {
-    "primary": "e21d31",
-    "[light]": {"foreground": "480910", "background": "fcf8f8"},
-    "[dark]": {"foreground": "fbdfe2", "background": "231f1f"}
-}
-
-
-def _get_colours() -> dict:
-    now = datetime.now()
-
-    if now.year >= 2025:
-        print("I certainly hope not")
-
-    if now.month == 3 and now.day == 17:
-        # And this is on the weekend...
-        return {
-            "[dark]": {"primary": "08ff00"},
-            "[light]": {"primary": "06c200"}
-        }
-    elif now.month == 2 and now.day == 14:
-        print("Why are you looking at canvas? Don't you have something better to do?")
-
-        # Nobody will ever see this because uni starts around the 20th
-        # Too bad, I kinda liked the theme
-        return red_theme
-    elif now.month == 8 and now.day == 20:
-        # Some random day... I just wanted to see the red theme
-        return red_theme
-    else:
-        return {"primary": "FF804F"}

qcanvas/util/link_scanner/__init__.py

@@ -1,2 +0,0 @@
-from .canvas_link_scanner import CanvasFileScanner
-from .resource_scanner import ResourceScanner

qcanvas/util/link_scanner/canvas_link_scanner.py

@@ -1,41 +0,0 @@
-from bs4 import Tag
-from httpx import URL
-
-from qcanvas import db as db
-from qcanvas.net.canvas import CanvasClient
-from qcanvas.util.link_scanner.resource_scanner import ResourceScanner
-
-canvas_resource_id_prefix = "canvas_file"
-
-
-class CanvasFileScanner(ResourceScanner):
-    _canvas_client: CanvasClient
-
-    def __init__(self, canvas_client: CanvasClient):
-        self._canvas_client = canvas_client
-
-    def accepts_link(self, link: Tag) -> bool:
-        if link.name not in ["a", "img"]:
-            return False
-
-        return "data-api-returntype" in link.attrs.keys() and link["data-api-returntype"] == "File"
-
-    async def extract_resource(self, link: Tag, file_id: str) -> db.Resource:
-        return db.convert_legacy_file(await self._canvas_client.get_file_from_endpoint(link["data-api-endpoint"]))
-
-    def extract_id(self, link: Tag) -> str:
-        # https://canvas.newcastle.edu.au/courses/27716/files/5975585/...
-        # --------------------------------- Extract this part ^^^^^^^
-        return URL(link["data-api-endpoint"]).path.rsplit('/', 2)[-1]
-
-    async def download(self, resource):
-        path = resource.download_location
-        path.parent.mkdir(parents=True, exist_ok=True)
-
-        with open(path, "wb") as file:
-            async for progress in self._canvas_client.download_file(resource, file):
-                yield progress
-
-    @property
-    def name(self) -> str:
-        return canvas_resource_id_prefix

qcanvas/util/link_scanner/canvas_media_object_scanner.py

@@ -1,60 +0,0 @@
-import json
-from typing import Any
-
-from bs4 import Tag, BeautifulSoup
-from httpx import AsyncClient
-
-from qcanvas import db as db
-from qcanvas.util.link_scanner import ResourceScanner
-
-
-class CanvasMediaObjectScanner(ResourceScanner):
-
-    def __init__(self, client: AsyncClient):
-        self.client = client
-
-    @property
-    def name(self) -> str:
-        return "canvas_media_object"
-
-    def accepts_link(self, link: Tag) -> bool:
-        return (
-                link.name == "iframe"
-                and "data-media-type" in link.attrs.keys()
-                and link.attrs["data-media-type"] == "video"
-        )
-
-    async def extract_resource(self, link: Tag, file_id: str) -> db.Resource:
-        # Get the page for the embedded player (I could not find another way to get the needed data from canvas)
-        response = (await self.client.get(link.attrs["src"])).text
-        # Parse the HTML response
-        doc = BeautifulSoup(response, "html.parser")
-        media_data: None | dict[str, Any] = None
-
-        # Find all script tags (one of them has the data we are interested in)
-        for script_tag in doc.find_all("script", {}):
-            body = script_tag.text.strip()
-
-            # If the tag content starts with this then it has the data we want
-            if "INST = {" in body:
-                # Find the data that we are interested in (is on a line that starts with "ENV = ")
-                line: str = next(filter(lambda x: x.strip().startswith("ENV ="), script_tag.text.splitlines()))
-                # Parse the json embedded in the script tag
-                media_data = json.loads(line.lstrip("ENV = ").rstrip(";"))["media_object"]
-                break
-
-        if media_data is None:
-            raise Exception("Could not extract media info")
-
-        # The highest quality stream is the first
-        media_source = media_data["media_sources"][0]
-
-        return db.Resource(
-            id=file_id,
-            url=media_source["src"],
-            file_name=media_data["title"],
-            file_size=int(media_source["size"]) * 1024  # Seems to be recorded in KiB, not bytes
-        )
-
-    def extract_id(self, link: Tag) -> str:
-        return link.attrs["data-media-id"]

qcanvas/util/link_scanner/dropbox_scanner.py

@@ -1,68 +0,0 @@
-import httpx
-from bs4 import Tag
-from httpx import URL
-
-from qcanvas import db as db
-from qcanvas.util.link_scanner import ResourceScanner
-
-
-# from httpx import URL
-
-
-def parse_content_disposition(header: str) -> dict[str, str | None]:
-    bad_chars = "\" \t"
-    result = {}
-
-    for statement in header.split(";"):
-        split = statement.split("=", 2)
-
-        result[split[0].strip(bad_chars)] = None if len(split) == 1 else split[1].strip(bad_chars)
-
-    return result
-
-
-class DropboxScanner(ResourceScanner):
-    def __init__(self, client: httpx.AsyncClient):
-        self.client = client
-
-    def accepts_link(self, link: Tag) -> bool:
-        if link.name != "a":
-            return False
-
-        if "href" in link.attrs:
-            url = URL(link.attrs["href"])
-
-            return url.host == "www.dropbox.com" and url.path.split("/", 2)[1] == "s"
-        else:
-            return False
-
-    async def extract_resource(self, link: Tag, file_id: str) -> db.Resource:
-        url = URL(link.attrs["href"]).copy_set_param("dl", 1)
-
-        req = self.client.build_request(
-            method="GET",
-            url=url
-        )
-
-        # The following code essentially starts downloading the file, reads the headers and then stops downloading it,
-        # just to ge the size of the file
-        resp = await self.client.send(req, follow_redirects=True, stream=True)
-
-        try:
-            resp.raise_for_status()
-
-            filename = parse_content_disposition(resp.headers["content-disposition"])["filename"]
-            size = int(resp.headers["content-length"])
-
-            return db.Resource(id=file_id, url=str(url), file_name=filename, file_size=size)
-        finally:
-            await resp.aclose()
-
-    def extract_id(self, link: Tag) -> str:
-        # https://www.dropbox.com/s/vwk48ajl9nw6pqh/Lab1_ENGG1500_robot.pdf?dl=0
-        # ------- Extract this part ^^^^^^^^^^^^^^^
-        return URL(link.attrs["href"]).path.split("/", 3)[2]
-
-    @property
-    def name(self) -> str:
-        return "dropbox"

qcanvas/util/link_scanner/resource_scanner.py

@@ -1,69 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import AsyncIterator
-
-import httpx
-from bs4 import Tag
-
-import qcanvas.db as db
-
-
-class ResourceScanner(ABC):
-    """
-    A resource scanner extracts resources from canvas pages.
-    The resource may be an embedded video, a file or anything that will be of use to the user.
-    Each scanner should be responsible for only 1 type of resource.
-    """
-
-    @property
-    @abstractmethod
-    def name(self) -> str:
-        """
-        The name of the resource scanner.
-        Will be attached to the resource id externally.
-        """
-        ...
-
-    @abstractmethod
-    def accepts_link(self, link: Tag) -> bool:
-        """
-        Whether this resource scanner accepts the specified link
-        """
-        ...
-
-    @abstractmethod
-    async def extract_resource(self, link: Tag, file_id: str) -> db.Resource:
-        """
-        Extract information about the resource in the specified tag
-        Parameters
-        ----------
-        link
-            The element that links to the resource
-        file_id
-            The id of the file (as produced from `extract_id`)
-        Returns
-        -------
-            The resource
-        """
-        ...
-
-    @abstractmethod
-    def extract_id(self, link: Tag) -> str:
-        """
-        Extracts a unique id from a file link
-        """
-        ...
-
-    async def download(self, resource: db.Resource) -> AsyncIterator[int]:
-        yield 0
-
-        download_destination = resource.download_location
-        download_destination.parent.mkdir(parents=True, exist_ok=True)
-
-        with open(download_destination, "wb") as file:
-            async with httpx.AsyncClient(follow_redirects=True) as client:
-                async with client.stream(method='get', url=resource.url) as resp:
-                    resp.raise_for_status()
-
-                    async for chunk in resp.aiter_bytes():
-                        file.write(chunk)
-                        yield resp.num_bytes_downloaded

qcanvas/util/progress_reporter.py

@@ -1,101 +0,0 @@
-import itertools
-from abc import ABC, abstractmethod
-from typing import Any
-
-
-class ProgressSection:
-    """
-    Convenience class for reporting on a section of a larger task
-    """
-
-    def __init__(self, section_name: str, total_progress: int, reporter: "ProgressReporter"):
-        self.total_progress = total_progress
-        self.reporter = reporter
-        self._counter = itertools.count(1)  # Start at 1 instead of 0
-        self.reporter.section_started(section_name, total_progress)
-
-    def increment_progress(self, *args):
-        self.reporter.progress(next(self._counter), self.total_progress)
-
-
-class ProgressReporter(ABC):
-    """
-    A progress reporter is passed to a function which then uses it to report the progress for whatever task it performs to another place.
-    Only 1 section should be active at a time.
-    """
-
-    @abstractmethod
-    def section_started(self, section_name: str, total_progress: int) -> None:
-        """
-        Signals that a new section of a task has started
-        Parameters
-        ----------
-        section_name
-            The name of the new task section
-        """
-        ...
-
-    @abstractmethod
-    def progress(self, current_progress: int, total_progress: int) -> None:
-        """
-        Updates the current progress of the current task
-        Parameters
-        ----------
-        current_progress
-            The current amount of progress, e.g. the number of bytes of a file that have been downloaded
-        total_progress
-            The total or final amount of progress, e.g. the size of a download
-        """
-        ...
-
-    @abstractmethod
-    def finished(self) -> None:
-        """
-        Signals that the task is finished and there is nothing left to do
-        """
-        ...
-
-    @abstractmethod
-    def errored(self, context: Any) -> None:
-        """
-        Signals that the task could not be completed
-        Parameters
-        ----------
-        context
-            Any information about why the task failed
-        """
-        ...
-
-    def section(self, section_name: str, total_progress: int) -> ProgressSection:
-        """
-        Creates a ProgressSection for this reporter, for reporting on a section of a larger task
-        Parameters
-        ----------
-        section_name
-            The name of the section
-        total_progress
-            The total or final amount of progress, e.g. the size of a download
-        Returns
-        -------
-        ProgressSection
-            The created section
-        """
-        return ProgressSection(section_name, total_progress, self)
-
-
-class _NoopReporter(ProgressReporter):
-
-    def section_started(self, section_name: str, total_progress: int) -> None:
-        pass
-
-    def progress(self, current_progress: int, total: int) -> None:
-        pass
-
-    def finished(self) -> None:
-        pass
-
-    def errored(self, context: Any) -> None:
-        pass
-
-
-noop_reporter = _NoopReporter()

qcanvas/util/self_updater.py

@@ -1,55 +0,0 @@
-import asyncio
-import json
-import os
-from importlib.metadata import version
-
-import httpx
-from packaging.version import Version
-
-from qcanvas.util.constants import package_name
-
-# When true, signals that the program should be restarted when it closes next
-restart_flag = False
-
-
-async def do_update() -> None:
-    """
-    Updates the qcanvas package and sets the restart flag.
-    The restart flag is passed back to the launcher script as a return code.
-    """
-    global restart_flag
-    await asyncio.to_thread(os.system, f"pip install --upgrade {package_name}")
-    restart_flag = True
-
-
-async def get_newer_version() -> tuple[Version | None, Version | None] | None:
-    """
-    Check for a newer version of qcanvas
-    Returns
-    -------
-    tuple
-        A tuple, where the first item is the latest version and the second item is the installed version. If the installed
-        version is up-to-date, then the first item is None
-    """
-    latest_version = await get_latest_version()
-    installed_version = Version(version(package_name))
-
-    print(f"latest = {latest_version}, installed = {installed_version}")
-
-    if installed_version < latest_version:
-        return latest_version, installed_version
-    else:
-        return None, installed_version
-
-
-async def get_latest_version() -> Version:
-    """
-    Retrieves the latest version of the package from pypi
-    Returns
-    -------
-    Version
-        The latest version of qcanvas on pypi
-    """
-    async with httpx.AsyncClient() as client:
-        data = json.loads((await client.get(f"https://pypi.org/pypi/{package_name}/json")).text)
-        return Version(data["info"]["version"])