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

qcanvas/net/canvas/canvas_client.py

@@ -1,209 +0,0 @@
-import asyncio
-import json
-import logging
-from typing import BinaryIO, AsyncIterator, Any
-
-import gql
-import httpx
-from gql.transport.exceptions import TransportQueryError
-from httpx import URL, Response
-from tenacity import retry, wait_exponential, wait_random, stop_after_attempt, wait_fixed, \
-    retry_if_exception_type
-
-import qcanvas.db as db
-from qcanvas.net.canvas.legacy_canvas_types import LegacyFile, LegacyPage
-from qcanvas.net.custom_httpx_async_transport import CustomHTTPXAsyncTransport
-from qcanvas.net.self_authenticating import SelfAuthenticatingWithHttpClient, AuthenticationException
-
-
-class RatelimitedException(Exception):
-    def __init__(self):
-        super().__init__("Canvas is ratelimiting me yay")
-
-
-class UnauthenticatedException(Exception):
-    def __init__(self):
-        super().__init__("Trust me bro i'm authenticated")
-
-
-def detect_unauthenticated_and_raise(response: Response) -> Response:
-    """
-    Detects if a response is redirecting us to the login page or is giving us a 401 (unauthorised)
-    :param response: The response to check
-    :return: True if reauthentication is needed
-    """
-    if response.url.path == "/login/canvas" or response.status_code == 401:
-        raise UnauthenticatedException()
-
-    return response
-
-
-def detect_ratelimit_and_raise(response: Response) -> Response:
-    # Who the FUCK decided to use 403 instead of 429?? With this stupid message??
-    # Fuck you instructure, learn to code
-    # And the newline at the end for some fucking reason is the cherry on top...
-    if response.status_code == 403 and response.text == "403 Forbidden (Rate Limit Exceeded)\n":
-        raise RatelimitedException()
-
-    return response
-
-
-class CanvasClient(SelfAuthenticatingWithHttpClient):
-    _logger = logging.getLogger("canvas_client")
-    _net_op_sem = asyncio.Semaphore(20)
-
-    @staticmethod
-    async def verify_config(canvas_url: str, api_key: str) -> bool:
-        """
-        Makes a request to canvas to verify that the url and key are correct.
-        :param canvas_url: The canvas url to verify
-        :param api_key: The api key to verify
-        :return: True if everything looks ok, false if the api key or url is wrong
-        """
-        client = httpx.AsyncClient()
-        # Make a request to an endpoint that returns very little/no data (for students at least) to check if everything
-        # is working
-        response = await client.get(url=URL(canvas_url).join("api/v1/accounts"),
-                                    headers={"Authorization": f"Bearer {api_key}"}, timeout=10)
-
-        return response.is_success
-
-    def __init__(self, canvas_url: URL, api_key: str, client: httpx.AsyncClient | None = None):
-        super().__init__(client=client or httpx.AsyncClient(timeout=60))
-        self.api_key = api_key
-        self.canvas_url = canvas_url
-
-    def get_headers(self) -> dict[str, dict]:
-        return {"headers": {"Authorization": f"Bearer {self.api_key}"}}
-
-    @retry(
-        wait=wait_exponential(exp_base=1.2, max=10) + wait_random(0, 1),
-        retry=retry_if_exception_type(RatelimitedException),
-        stop=stop_after_attempt(8)
-    )
-    async def get_courses(self):
-        with self._net_op_sem:
-            return await self.client.get(self.canvas_url.join("api/v1/courses"))
-
-    @retry(
-        wait=wait_exponential(exp_base=1.2, max=10) + wait_random(0, 1),
-        retry=retry_if_exception_type(RatelimitedException),
-        stop=stop_after_attempt(8)
-    )
-    async def get_page(self, page_id: str | int, course_id: str | int) -> LegacyPage:
-        async with self._net_op_sem:
-            response = detect_ratelimit_and_raise(
-                await self.client.get(self.canvas_url.join(f"api/v1/courses/{course_id}/pages/{page_id}"),
-                                      **self.get_headers()))
-
-            return LegacyPage.from_dict(json.loads(response.text))
-
-    @retry(
-        wait=wait_exponential(exp_base=1.2, max=10) + wait_random(0, 1),
-        retry=retry_if_exception_type(RatelimitedException),
-        stop=stop_after_attempt(8)
-    )
-    async def get_file(self, file_id: str | int, course_id: str | int) -> LegacyFile:
-        async with self._net_op_sem:
-            response = detect_ratelimit_and_raise(
-                await self.client.get(self.canvas_url.join(f"api/v1/courses/{course_id}/files/{file_id}"),
-                                      **self.get_headers()))
-
-            response.raise_for_status()
-
-            return LegacyFile.from_dict(json.loads(response.text))
-
-    @retry(
-        wait=wait_exponential(exp_base=1.2, max=10) + wait_random(0, 1),
-        retry=retry_if_exception_type(RatelimitedException),
-        stop=stop_after_attempt(8)
-    )
-    async def get_file_from_endpoint(self, endpoint_url: str) -> LegacyFile:
-        async with self._net_op_sem:
-            response = detect_ratelimit_and_raise(await self.client.get(endpoint_url, **self.get_headers()))
-
-            response.raise_for_status()
-
-            return LegacyFile.from_dict(json.loads(response.text))
-
-    @retry(
-        wait=wait_exponential(exp_base=1.2, max=10) + wait_random(0, 1),
-        retry=retry_if_exception_type(RatelimitedException),
-        stop=stop_after_attempt(8)
-    )
-    async def get_temp_session_link(self) -> str | None:
-        """
-        Gets the link which will authenticate a browser/open canvas using a 'legacy session token'
-        Returns
-        -------
-        str | None
-            The url as a string if the request succeeded, None if it didn't
-        """
-
-        token_response = await self.client.get(self.canvas_url.join("login/session_token"), **self.get_headers())
-
-        if token_response.is_success:
-            return json.loads(token_response.text)["session_url"]
-        else:
-            return None
-
-    @retry(
-        stop=stop_after_attempt(3),
-        wait=wait_fixed(5) + wait_random(0, 1),
-        retry=retry_if_exception_type(TransportQueryError)
-    )
-    async def do_graphql_query(self, query: gql.client.DocumentNode, **kwargs) -> dict[str, Any]:
-        async with self._net_op_sem:
-            gql_transport = CustomHTTPXAsyncTransport(self.client, self.canvas_url.join("api/graphql"),
-                                                      **self.get_headers())
-            gql_client = gql.Client(transport=gql_transport, execute_timeout=60)
-
-            return await gql_client.execute_async(query, variable_values=kwargs)
-
-    async def download_file(self, resource: db.Resource, download_destination: BinaryIO) -> AsyncIterator[int]:
-        yield 0
-        retries = 0
-
-        while retries < self.max_retries:
-            async with self.client.stream(method='GET', url=resource.url, cookies=self.client.cookies,
-                                          follow_redirects=True) as resp:
-                if await self.reauthenticate_if_needed(resp):
-                    retries += 1
-                    self._logger.warning("Retrying download of %s", resource.url)
-                    continue
-
-                async for chunk in resp.aiter_bytes():
-                    download_destination.write(chunk)
-                    yield resp.num_bytes_downloaded
-
-                return
-
-        self._logger.warning("Gave up download of %s", resource.url)
-        raise
-
-    async def do_request_and_retry_if_unauthenticated(self, url: URL, method: str, **kwargs) -> httpx.Response:
-        # Add API token to the request
-        return await super().do_request_and_retry_if_unauthenticated(url, method, **kwargs, **self.get_headers())
-
-    def detect_authentication_needed(self, response: Response):
-        # Canvas will silently redirect to the login page or give a 401 if we are not authenticated
-        return response.url.path == "/login/canvas" or response.status_code == 401
-
-    async def _authenticate(self):
-        token_response = await self.client.get(self.canvas_url.join("login/session_token"), **self.get_headers())
-
-        if token_response.is_success:
-            session_url = json.loads(token_response.text)["session_url"]
-            self._logger.debug("Got token response for authentication")
-
-            if session_url is not None:
-                # Headers are not needed here
-                req = await self.client.get(session_url)
-                if req.status_code != 302:
-                    self._logger.error("Error when activating session from request")
-                    raise AuthenticationException("Authentication was not successful")
-            else:
-                raise AuthenticationException("Token response body was malformed")
-        else:
-            self._logger.error("Authentication failed, API key may be invalid")
-            raise AuthenticationException("Authentication failed, check your API key")

qcanvas/net/canvas/legacy_canvas_types.py

@@ -1,124 +0,0 @@
-from typing import Any, TypeVar, Type, cast
-
-T = TypeVar("T")
-
-
-def from_bool(x: Any) -> bool:
-    assert isinstance(x, bool)
-    return x
-
-
-def from_str(x: Any) -> str:
-    assert isinstance(x, str)
-    return x
-
-
-def from_int(x: Any) -> int:
-    assert isinstance(x, int) and not isinstance(x, bool)
-    return x
-
-
-def to_class(c: Type[T], x: Any) -> dict:
-    assert isinstance(x, c)
-    return cast(Any, x).to_dict()
-
-
-class LegacyPage:
-    published: bool
-    hide_from_students: bool
-    locked_for_user: bool
-    body: str | None
-
-    def __init__(self, published: bool, hide_from_students: bool, locked_for_user: bool, body: str | None) -> None:
-        self.published = published
-        self.hide_from_students = hide_from_students
-        self.locked_for_user = locked_for_user
-        self.body = body
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'LegacyPage':
-        assert isinstance(obj, dict)
-        published = from_bool(obj.get("published"))
-        hide_from_students = from_bool(obj.get("hide_from_students"))
-        locked_for_user = from_bool(obj.get("locked_for_user"))
-        body = None if locked_for_user else from_str(obj.get("body"))
-        return LegacyPage(published, hide_from_students, locked_for_user, body)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["published"] = from_bool(self.published)
-        result["hide_from_students"] = from_bool(self.hide_from_students)
-        result["locked_for_user"] = from_bool(self.locked_for_user)
-        result["body"] = from_str(self.body)
-        return result
-
-
-class LegacyFile:
-    id: int
-    uuid: str
-    display_name: str
-    filename: str
-    url: str
-    size: int
-    locked: bool
-    hidden: bool
-    hidden_for_user: bool
-    locked_for_user: bool
-
-    def __init__(self, id: int, uuid: str, display_name: str, filename: str, url: str, size: int, locked: bool,
-                 hidden: bool, hidden_for_user: bool, locked_for_user: bool) -> None:
-        self.id = id
-        self.uuid = uuid
-        self.display_name = display_name
-        self.filename = filename
-        self.url = url
-        self.size = size
-        self.locked = locked
-        self.hidden = hidden
-        self.hidden_for_user = hidden_for_user
-        self.locked_for_user = locked_for_user
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'LegacyFile':
-        assert isinstance(obj, dict)
-        id = from_int(obj.get("id"))
-        uuid = from_str(obj.get("uuid"))
-        display_name = from_str(obj.get("display_name"))
-        filename = from_str(obj.get("filename"))
-        url = from_str(obj.get("url"))
-        size = from_int(obj.get("size"))
-        locked = from_bool(obj.get("locked"))
-        hidden = from_bool(obj.get("hidden"))
-        hidden_for_user = from_bool(obj.get("hidden_for_user"))
-        locked_for_user = from_bool(obj.get("locked_for_user"))
-        return LegacyFile(id, uuid, display_name, filename, url, size, locked, hidden, hidden_for_user, locked_for_user)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["id"] = from_int(self.id)
-        result["uuid"] = from_str(self.uuid)
-        result["display_name"] = from_str(self.display_name)
-        result["filename"] = from_str(self.filename)
-        result["url"] = from_str(self.url)
-        result["size"] = from_int(self.size)
-        result["locked"] = from_bool(self.locked)
-        result["hidden"] = from_bool(self.hidden)
-        result["hidden_for_user"] = from_bool(self.hidden_for_user)
-        result["locked_for_user"] = from_bool(self.locked_for_user)
-        return result
-
-
-def legacy_page_from_dict(s: Any) -> LegacyPage:
-    return LegacyPage.from_dict(s)
-
-
-def legacy_page_to_dict(x: LegacyPage) -> Any:
-    return to_class(LegacyPage, x)
-
-
-def legacy_file_from_dict(s: Any) -> LegacyFile:
-    return LegacyFile.from_dict(s)
-
-
-def legacy_file_to_dict(x: LegacyFile) -> Any:
-    return to_class(LegacyFile, x)

qcanvas/net/custom_httpx_async_transport.py

@@ -1,34 +0,0 @@
-from typing import Union, Optional, Dict, Any
-
-import httpx
-from gql.transport.httpx import HTTPXAsyncTransport
-from graphql import DocumentNode
-
-
-class CustomHTTPXAsyncTransport(HTTPXAsyncTransport):
-    """:ref:`Async Transport <async_transports>` used to execute GraphQL queries
-    on remote servers.
-
-    The transport uses the httpx library with anyio.
-    """
-
-    def __init__(self, client: httpx.AsyncClient, url: Union[str, httpx.URL], headers: dict[str, Any] | None = None,
-                 **kwargs):
-        super().__init__(url=url, **kwargs)
-        self.client = client
-        self.headers = headers or {}
-
-    async def connect(self):
-        pass
-
-    async def close(self):
-        """Do not close the client. We want to keep it."""
-        pass
-
-    def _prepare_request(self, document: DocumentNode, variable_values: Optional[Dict[str, Any]] = None,
-                         operation_name: Optional[str] = None, extra_args: Optional[Dict[str, Any]] = None,
-                         upload_files: bool = False) -> Dict[str, Any]:
-        result = super()._prepare_request(document, variable_values, operation_name, extra_args, upload_files)
-        result["headers"] = self.headers
-
-        return result

qcanvas/net/self_authenticating.py

@@ -1,108 +0,0 @@
-import logging
-from abc import ABC, abstractmethod
-from asyncio import Lock, Event
-
-import httpx
-from httpx import URL
-
-
-class AuthenticationException(Exception):
-    pass
-
-
-# httpx does have an authentication flow mechanism that allows you to also make other requests but I don't know if it
-# will behave the same way as this does. I also finished this before I found out that existed.
-
-class SelfAuthenticatingWithHttpClient(ABC):
-    _logger = logging.getLogger(__name__)
-
-    def __init__(self, max_retires: int = 3, client: httpx.AsyncClient = httpx.AsyncClient()):
-        self.authentication_lock = Lock()
-        self.client = client
-        self.authentication_in_progress: Event | None = None
-        self.max_retries = max_retires
-
-    async def reauthenticate(self) -> None:
-        """
-        Re-authenticates the client
-        """
-
-        # Acquire the lock as to prevent multiple threads from modifying self.authentication_in_progress.
-        # Not that will ever happen using asyncio alone because python async is not actually multi-processed
-        await self.authentication_lock.acquire()
-
-        # If there's no authentication already in progress
-        if self.authentication_in_progress is None:
-            # Update authentication_in_progress and release the lock
-            self.authentication_in_progress = Event()
-            self.authentication_lock.release()
-
-            # Start the authentication
-            self._logger.info(f"Authenticating {self.__class__.__name__}")
-            await self._authenticate()
-            self._logger.info(f"Finished authenticating {self.__class__.__name__}")
-            # Update the event to unblock other coroutines
-            self.authentication_in_progress.set()
-
-            # Delete authentication_in_progress to indicate that authentication is no longer in progress
-            # This lock is probably not needed (due to not actually being multi-processed) but shouldn't hurt
-            await self.authentication_lock.acquire()
-            self.authentication_in_progress = None
-            self.authentication_lock.release()
-        # Authentication is already in progress
-        else:
-            # Get a reference to the event
-            event = self.authentication_in_progress
-            # Release the lock as we are not going to access it anymore
-            self.authentication_lock.release()
-
-            # Wait for the reauthentication to finish
-            self._logger.info(f"Waiting for {self.__class__.__name__}")
-            await event.wait()
-            self._logger.info(f"Finished waiting for {self.__class__.__name__}")
-
-    async def do_request_and_retry_if_unauthenticated(self, url: URL, method: str, **kwargs) -> httpx.Response:
-        """
-        Executes a http request or reauthenticate and retries if needed
-        :param url: The url of the request
-        :param method: The method the request should use (post, get, etc)
-        :return:
-        """
-        retries = 0
-
-        async def make_request():
-            return await self.client.request(url=url, method=method, **kwargs)
-
-        # Make the initial request
-        response = await make_request()
-
-        # Retry if canvas is trying to get us to reauthenticate
-        while (await self.reauthenticate_if_needed(response)) and retries < self.max_retries:
-            response = await make_request()
-            retries += 1
-
-        return response
-
-    async def reauthenticate_if_needed(self, response: httpx.Response) -> bool:
-        """
-        Inspects a response and activates reauthentication if the response indicates we need to
-        :param response: The response to inspect
-        :return: True if reauthentication was activated, false if not
-        """
-
-        if self.detect_authentication_needed(response):
-            await self.reauthenticate()
-            return True
-
-        return False
-
-    @abstractmethod
-    def detect_authentication_needed(self, response: httpx.Response) -> bool:
-        ...
-
-    @abstractmethod
-    async def _authenticate(self) -> None:
-        """
-        Authenticates the client
-        """
-        ...

qcanvas/queries/__init__.py

@@ -1,4 +0,0 @@
-from .all_courses import AllCoursesQueryData
-from .canvas_course_data import Term, Assignment, AssignmentConnection, ModuleItemInterface, File, Page, \
-    ModuleItem, \
-    Module, ModuleConnection, CanvasCourseData as Course

qcanvas/queries/all_courses.gql

@@ -1,7 +0,0 @@
-# qenerate: plugin=pydantic_v1
-
-query AllCourses($detailed: Boolean!) {
-    allCourses {
-        ...CanvasCourseData
-    }
-}

qcanvas/queries/all_courses.py

@@ -1,108 +0,0 @@
-"""
-Generated by qenerate plugin=pydantic_v1. DO NOT MODIFY MANUALLY!
-"""
-from collections.abc import Callable  # noqa: F401 # pylint: disable=W0611
-from datetime import datetime  # noqa: F401 # pylint: disable=W0611
-from enum import Enum  # noqa: F401 # pylint: disable=W0611
-from typing import (  # noqa: F401 # pylint: disable=W0611
-    Any,
-    Optional,
-    Union,
-)
-
-from pydantic import (  # noqa: F401 # pylint: disable=W0611
-    BaseModel,
-    Extra,
-    Field,
-    Json,
-)
-
-from qcanvas.queries.canvas_course_data import CanvasCourseData
-
-DEFINITION = """
-fragment CanvasCourseData on Course {
-    _id
-#    id
-    name
-    courseNickname
-    term {
-        endAt
-        startAt
-        name
-        id
-    }
-    assignmentsConnection @include(if: $detailed) {
-        nodes {
-            description
-            courseId
-            dueAt
-            createdAt
-            id
-            name
-            position
-            updatedAt
-        }
-    }
-    modulesConnection @include(if: $detailed) {
-        nodes {
-            name
-            id
-            moduleItems {
-                content {
-                    ... on File {
-                        _id
-                        displayName
-                        createdAt
-                        updatedAt
-                        url
-                        size
-                        mimeClass
-                        contentType
-                    }
-                    ... on Page {
-                        _id
-                        title
-                        updatedAt
-                        createdAt
-                    }
-                }
-            }
-        }
-    }
-}
-
-query AllCourses($detailed: Boolean!) {
-  allCourses {
-    ...CanvasCourseData
-  }
-}
-"""
-
-
-class ConfiguredBaseModel(BaseModel):
-    class Config:
-        smart_union = True
-        extra = Extra.forbid
-
-
-class AllCoursesQueryData(ConfiguredBaseModel):
-    all_courses: Optional[list[CanvasCourseData]] = Field(..., alias="allCourses")
-
-
-def query(query_func: Callable, **kwargs: Any) -> AllCoursesQueryData:
-    """
-    This is a convenience function which queries and parses the data into
-    concrete types. It should be compatible with most GQL clients.
-    You do not have to use it to consume the generated data classes.
-    Alternatively, you can also mime and alternate the behavior
-    of this function in the caller.
-
-    Parameters:
-        query_func (Callable): Function which queries your GQL Server
-        kwargs: optional arguments that will be passed to the query function
-
-    Returns:
-        AllCoursesQueryData: queried data parsed into generated classes
-    """
-    raw_data: dict[Any, Any] = query_func(DEFINITION, **kwargs)
-    return AllCoursesQueryData(**raw_data)

qcanvas/queries/canvas_course_data.gql

@@ -1,51 +0,0 @@
-# qenerate: plugin=pydantic_v1
-
-fragment CanvasCourseData on Course {
-    _id
-    name
-    courseNickname
-    term {
-        endAt
-        startAt
-        name
-        id
-    }
-    assignmentsConnection @include(if: $detailed) {
-        nodes {
-            description
-            courseId
-            dueAt
-            createdAt
-            id
-            name
-            position
-            updatedAt
-        }
-    }
-    modulesConnection @include(if: $detailed) {
-        nodes {
-            name
-            id
-            moduleItems {
-                content {
-                    ... on File {
-                        _id
-                        displayName
-                        createdAt
-                        updatedAt
-                        url
-                        size
-                        mimeClass
-                        contentType
-                    }
-                    ... on Page {
-                        _id
-                        title
-                        updatedAt
-                        createdAt
-                    }
-                }
-            }
-        }
-    }
-}