From fe4def75dc0a316789cec068a574713a2b2af92f Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Tue, 12 Jul 2022 09:25:05 +0400
Subject: Add GitHub Artifact API View

Adds an API route to fetch GitHub build artifacts through a GitHub app.

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/api/github_utils.py            | 183 ++++++++++++++++
 pydis_site/apps/api/tests/test_github_utils.py | 287 +++++++++++++++++++++++++
 pydis_site/apps/api/urls.py                    |   9 +-
 pydis_site/apps/api/views.py                   |  53 +++++
 4 files changed, 530 insertions(+), 2 deletions(-)
 create mode 100644 pydis_site/apps/api/github_utils.py
 create mode 100644 pydis_site/apps/api/tests/test_github_utils.py

(limited to 'pydis_site/apps/api')

diff --git a/pydis_site/apps/api/github_utils.py b/pydis_site/apps/api/github_utils.py
new file mode 100644
index 00000000..70dccdff
--- /dev/null
+++ b/pydis_site/apps/api/github_utils.py
@@ -0,0 +1,183 @@
+"""Utilities for working with the GitHub API."""
+
+import asyncio
+import datetime
+import math
+
+import httpx
+import jwt
+from asgiref.sync import async_to_sync
+
+from pydis_site import settings
+
+MAX_POLLS = 20
+"""The maximum number of attempts at fetching a workflow run."""
+
+
+class ArtifactProcessingError(Exception):
+    """Base exception for other errors related to processing a GitHub artifact."""
+
+    status: int
+
+
+class UnauthorizedError(ArtifactProcessingError):
+    """The application does not have permission to access the requested repo."""
+
+    status = 401
+
+
+class NotFoundError(ArtifactProcessingError):
+    """The requested resource could not be found."""
+
+    status = 404
+
+
+class ActionFailedError(ArtifactProcessingError):
+    """The requested workflow did not conclude successfully."""
+
+    status = 400
+
+
+class RunTimeoutError(ArtifactProcessingError):
+    """The requested workflow run was not ready in time."""
+
+    status = 408
+
+
+def generate_token() -> str:
+    """
+    Generate a JWT token to access the GitHub API.
+
+    The token is valid for roughly 10 minutes after generation, before the API starts
+    returning 401s.
+
+    Refer to:
+    https://docs.github.com/en/developers/apps/building-github-apps/authenticating-with-github-apps#authenticating-as-a-github-app
+    """
+    now = datetime.datetime.now()
+    return jwt.encode(
+        {
+            "iat": math.floor((now - datetime.timedelta(seconds=60)).timestamp()),  # Issued at
+            "exp": math.floor((now + datetime.timedelta(minutes=9)).timestamp()),  # Expires at
+            "iss": settings.GITHUB_OAUTH_APP_ID,
+        },
+        settings.GITHUB_OAUTH_KEY,
+        algorithm="RS256"
+    )
+
+
+async def authorize(owner: str, repo: str) -> httpx.AsyncClient:
+    """
+    Get an access token for the requested repository.
+
+    The process is roughly:
+        - GET app/installations to get a list of all app installations
+        - POST <app_access_token> to get a token to access the given app
+        - GET installation/repositories and check if the requested one is part of those
+    """
+    client = httpx.AsyncClient(
+        base_url=settings.GITHUB_API,
+        headers={"Authorization": f"bearer {generate_token()}"},
+        timeout=settings.TIMEOUT_PERIOD,
+    )
+
+    try:
+        # Get a list of app installations we have access to
+        apps = await client.get("app/installations")
+        apps.raise_for_status()
+
+        for app in apps.json():
+            # Look for an installation with the right owner
+            if app["account"]["login"] != owner:
+                continue
+
+            # Get the repositories of the specified owner
+            app_token = await client.post(app["access_tokens_url"])
+            app_token.raise_for_status()
+            client.headers["Authorization"] = f"bearer {app_token.json()['token']}"
+
+            repos = await client.get("installation/repositories")
+            repos.raise_for_status()
+
+            # Search for the request repository
+            for accessible_repo in repos.json()["repositories"]:
+                if accessible_repo["name"] == repo:
+                    # We've found the correct repository, and it's accessible with the current auth
+                    return client
+
+        raise NotFoundError(
+            "Could not find the requested repository. Make sure the application can access it."
+        )
+
+    except BaseException as e:
+        # Close the client if we encountered an unexpected exception
+        await client.aclose()
+        raise e
+
+
+async def wait_for_run(client: httpx.AsyncClient, run: dict) -> str:
+    """Wait for the provided `run` to finish, and return the URL to its artifacts."""
+    polls = 0
+    while polls <= MAX_POLLS:
+        if run["status"] != "completed":
+            # The action is still processing, wait a bit longer
+            polls += 1
+            await asyncio.sleep(10)
+
+        elif run["conclusion"] != "success":
+            # The action failed, or did not run
+            raise ActionFailedError(f"The requested workflow ended with: {run['conclusion']}")
+
+        else:
+            # The desired action was found, and it ended successfully
+            return run["artifacts_url"]
+
+        run = await client.get(run["url"])
+        run.raise_for_status()
+        run = run.json()
+
+    raise RunTimeoutError("The requested workflow was not ready in time.")
+
+
+@async_to_sync
+async def get_artifact(
+    owner: str, repo: str, sha: str, action_name: str, artifact_name: str
+) -> str:
+    """Get a download URL for a build artifact."""
+    client = await authorize(owner, repo)
+
+    try:
+        # Get the workflow runs for this repository
+        runs = await client.get(f"/repos/{owner}/{repo}/actions/runs", params={"per_page": 100})
+        runs.raise_for_status()
+        runs = runs.json()
+
+        # Filter the runs for the one associated with the given SHA
+        for run in runs["workflow_runs"]:
+            if run["name"] == action_name and sha == run["head_sha"]:
+                break
+        else:
+            raise NotFoundError(
+                "Could not find a run matching the provided settings in the previous hundred runs."
+            )
+
+        # Wait for the workflow to finish
+        url = await wait_for_run(client, run)
+
+        # Filter the artifacts, and return the download URL
+        artifacts = await client.get(url)
+        artifacts.raise_for_status()
+
+        for artifact in artifacts.json()["artifacts"]:
+            if artifact["name"] == artifact_name:
+                data = await client.get(artifact["archive_download_url"])
+                if data.status_code == 302:
+                    return str(data.next_request.url)
+
+                # The following line is left untested since it should in theory be impossible
+                data.raise_for_status()  # pragma: no cover
+
+        raise NotFoundError("Could not find an artifact matching the provided name.")
+
+    finally:
+        await client.aclose()
diff --git a/pydis_site/apps/api/tests/test_github_utils.py b/pydis_site/apps/api/tests/test_github_utils.py
new file mode 100644
index 00000000..dc17d609
--- /dev/null
+++ b/pydis_site/apps/api/tests/test_github_utils.py
@@ -0,0 +1,287 @@
+import asyncio
+import datetime
+import random
+import unittest
+from unittest import mock
+
+import django.test
+import httpx
+import jwt
+import rest_framework.response
+import rest_framework.test
+from django.urls import reverse
+
+from .. import github_utils
+
+
+def patched_raise_for_status(response: httpx.Response):
+    """Fake implementation of raise_for_status which does not need a request to be set."""
+    if response.status_code // 100 != 2:  # pragma: no cover
+        raise httpx.HTTPStatusError(
+            f"Non 2xx response code: {response.status_code}",
+            request=getattr(response, "_request", httpx.Request("GET", "")),
+            response=response
+        )
+
+
+class GeneralUtilityTests(unittest.TestCase):
+    """Test the utility methods which do not fit in another class."""
+
+    def test_token_generation(self):
+        """Test that the a valid JWT token is generated."""
+        def encode(payload: dict, _: str, algorithm: str, *args, **kwargs) -> str:
+            """
+            Intercept the encode method.
+
+            It is performed with an algorithm which does not require a PEM key, as it may
+            not be available in testing environments.
+            """
+            self.assertEqual("RS256", algorithm, "The GitHub App JWT must be signed using RS256.")
+            return original_encode(
+                payload, "secret-encoding-key", algorithm="HS256", *args, **kwargs
+            )
+
+        original_encode = jwt.encode
+        with mock.patch("jwt.encode", new=encode):
+            token = github_utils.generate_token()
+        decoded = jwt.decode(token, "secret-encoding-key", algorithms=["HS256"])
+
+        delta = datetime.timedelta(minutes=10)
+        self.assertAlmostEqual(decoded["exp"] - decoded["iat"], delta.total_seconds())
+        self.assertLess(decoded["exp"], (datetime.datetime.now() + delta).timestamp())
+
+
+@mock.patch("httpx.AsyncClient", autospec=True)
+@mock.patch("asyncio.sleep", new=mock.AsyncMock(return_value=asyncio.Future))
+@mock.patch("httpx.Response.raise_for_status", new=patched_raise_for_status)
+class WaitForTests(unittest.IsolatedAsyncioTestCase):
+    """Tests the wait_for utility."""
+
+    async def test_wait_for_successful_run(self, client_mock: mock.Mock):
+        """Test that the wait_for method handles successfully runs."""
+        final_url = "some_url" + str(random.randint(0, 10))
+
+        client_mock.get.side_effect = responses = [
+            httpx.Response(200, json={"status": "queued", "url": ""}),
+            httpx.Response(200, json={"status": "pending", "url": ""}),
+            httpx.Response(200, json={
+                "status": "completed",
+                "conclusion": "success",
+                "url": "",
+                "artifacts_url": final_url
+            })
+        ]
+
+        result = await github_utils.wait_for_run(client_mock, responses[0].json())
+        self.assertEqual(final_url, result)
+
+    async def test_wait_for_failed_run(self, client_mock: mock.Mock):
+        """Test that the wait_for method handles failed runs."""
+        client_mock.get.return_value = httpx.Response(200, json={
+            "status": "completed",
+            "conclusion": "failed",
+        })
+
+        with self.assertRaises(github_utils.ActionFailedError):
+            await github_utils.wait_for_run(client_mock, {"status": "pending", "url": ""})
+
+    async def test_wait_for_timeout(self, client_mock: mock.Mock):
+        """Test that the wait_for method quits after a few attempts."""
+        client_mock.get.side_effect = responses = [
+            httpx.Response(200, json={"status": "pending", "url": ""})
+        ] * (github_utils.MAX_POLLS + 5)
+
+        with self.assertRaises(github_utils.RunTimeoutError):
+            await github_utils.wait_for_run(client_mock, responses[0].json())
+
+
+async def get_response_authorize(
+    _: httpx.AsyncClient, request: httpx.Request, **__
+) -> httpx.Response:
+    """
+    Helper method for the authorize tests.
+
+    Requests are intercepted before being sent out, and the appropriate responses are returned.
+    """
+    path = request.url.path
+    auth = request.headers.get("Authorization")
+
+    if request.method == "GET":
+        if path == "/app/installations":
+            if auth == "bearer JWT initial token":
+                return httpx.Response(200, request=request, json=[{
+                    "account": {"login": "VALID_OWNER"},
+                    "access_tokens_url": "https://example.com/ACCESS_TOKEN_URL"
+                }])
+            else:
+                return httpx.Response(
+                    401, json={"error": "auth app/installations"}, request=request
+                )
+
+        elif path == "/installation/repositories":
+            if auth == "bearer app access token":
+                return httpx.Response(200, request=request, json={
+                    "repositories": [{
+                        "name": "VALID_REPO"
+                    }]
+                })
+            else:  # pragma: no cover
+                return httpx.Response(
+                    401, json={"error": "auth installation/repositories"}, request=request
+                )
+
+    elif request.method == "POST":
+        if path == "/ACCESS_TOKEN_URL":
+            if auth == "bearer JWT initial token":
+                return httpx.Response(200, request=request, json={"token": "app access token"})
+            else:  # pragma: no cover
+                return httpx.Response(401, json={"error": "auth access_token"}, request=request)
+
+    # Reaching this point means something has gone wrong
+    return httpx.Response(500, request=request)  # pragma: no cover
+
+
+@mock.patch("httpx.AsyncClient.send", new=get_response_authorize)
+@mock.patch.object(github_utils, "generate_token", new=mock.Mock(return_value="JWT initial token"))
+class AuthorizeTests(unittest.IsolatedAsyncioTestCase):
+    """Test the authorize utility."""
+
+    async def test_invalid_apps_auth(self):
+        """Test that an exception is raised if authorization was attempted with an invalid token."""
+        with mock.patch.object(github_utils, "generate_token", return_value="Invalid token"):
+            with self.assertRaises(httpx.HTTPStatusError) as error:
+                await github_utils.authorize("VALID_OWNER", "VALID_REPO")
+
+        exception: httpx.HTTPStatusError = error.exception
+        self.assertEqual(401, exception.response.status_code)
+        self.assertEqual("auth app/installations", exception.response.json()["error"])
+
+    async def test_missing_repo(self):
+        """Test that an exception is raised when the selected owner or repo are not available."""
+        with self.assertRaises(github_utils.NotFoundError):
+            await github_utils.authorize("INVALID_OWNER", "VALID_REPO")
+        with self.assertRaises(github_utils.NotFoundError):
+            await github_utils.authorize("VALID_OWNER", "INVALID_REPO")
+
+    async def test_valid_authorization(self):
+        """Test that an accessible repository can be accessed."""
+        client = await github_utils.authorize("VALID_OWNER", "VALID_REPO")
+        self.assertEqual("bearer app access token", client.headers.get("Authorization"))
+
+
+async def get_response_get_artifact(request: httpx.Request, **_) -> httpx.Response:
+    """
+    Helper method for the get_artifact tests.
+
+    Requests are intercepted before being sent out, and the appropriate responses are returned.
+    """
+    path = request.url.path
+
+    if "force_error" in path:
+        return httpx.Response(404, request=request)
+
+    if request.method == "GET":
+        if path == "/repos/owner/repo/actions/runs":
+            return httpx.Response(200, request=request, json={"workflow_runs": [{
+                "name": "action_name",
+                "head_sha": "action_sha"
+            }]})
+        elif path == "/artifact_url":
+            return httpx.Response(200, request=request, json={"artifacts": [{
+                "name": "artifact_name",
+                "archive_download_url": "artifact_download_url"
+            }]})
+        elif path == "/artifact_download_url":
+            response = httpx.Response(302, request=request)
+            response.next_request = httpx.Request("GET", httpx.URL("https://final_download.url"))
+            return response
+
+    # Reaching this point means something has gone wrong
+    return httpx.Response(500, request=request)  # pragma: no cover
+
+
+class ArtifactFetcherTests(unittest.IsolatedAsyncioTestCase):
+    """Test the get_artifact utility."""
+
+    def setUp(self) -> None:
+        self.call_args = ["owner", "repo", "action_sha", "action_name", "artifact_name"]
+        self.client = httpx.AsyncClient(base_url="https://example.com")
+
+        self.patchers = [
+            mock.patch.object(self.client, "send", new=get_response_get_artifact),
+            mock.patch.object(github_utils, "authorize", return_value=self.client),
+            mock.patch.object(github_utils, "wait_for_run", return_value="artifact_url"),
+        ]
+
+        for patcher in self.patchers:
+            patcher.start()
+
+    def tearDown(self) -> None:
+        for patcher in self.patchers:
+            patcher.stop()
+
+    def test_client_closed_on_errors(self):
+        """Test that the client is terminated even if an error occurs at some point."""
+        self.call_args[0] = "force_error"
+        with self.assertRaises(httpx.HTTPStatusError):
+            github_utils.get_artifact(*self.call_args)
+        self.assertTrue(self.client.is_closed)
+
+    def test_missing(self):
+        """Test that an exception is raised if the requested artifact was not found."""
+        cases = (
+            "invalid sha",
+            "invalid action name",
+            "invalid artifact name",
+        )
+        for i, name in enumerate(cases, 2):
+            with self.subTest(f"Test {name} raises an error"):
+                new_args = self.call_args.copy()
+                new_args[i] = name
+
+                with self.assertRaises(github_utils.NotFoundError):
+                    github_utils.get_artifact(*new_args)
+
+    def test_valid(self):
+        """Test that the correct download URL is returned for valid requests."""
+        url = github_utils.get_artifact(*self.call_args)
+        self.assertEqual("https://final_download.url", url)
+        self.assertTrue(self.client.is_closed)
+
+
+@mock.patch.object(github_utils, "get_artifact")
+class GitHubArtifactViewTests(django.test.TestCase):
+    """Test the GitHub artifact fetch API view."""
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+
+        cls.kwargs = {
+            "owner": "test_owner",
+            "repo": "test_repo",
+            "sha": "test_sha",
+            "action_name": "test_action",
+            "artifact_name": "test_artifact",
+        }
+        cls.url = reverse("api:github-artifacts", kwargs=cls.kwargs)
+
+    async def test_successful(self, artifact_mock: mock.Mock):
+        """Test a proper response is returned with proper input."""
+        artifact_mock.return_value = "final download url"
+        result = self.client.get(self.url)
+
+        self.assertIsInstance(result, rest_framework.response.Response)
+        self.assertEqual({"url": artifact_mock.return_value}, result.data)
+
+    async def test_failed_fetch(self, artifact_mock: mock.Mock):
+        """Test that a proper error is returned when the request fails."""
+        artifact_mock.side_effect = github_utils.NotFoundError("Test error message")
+        result = self.client.get(self.url)
+
+        self.assertIsInstance(result, rest_framework.response.Response)
+        self.assertEqual({
+            "error_type": github_utils.NotFoundError.__name__,
+            "error": "Test error message",
+            "requested_resource": "/".join(self.kwargs.values())
+        }, result.data)
diff --git a/pydis_site/apps/api/urls.py b/pydis_site/apps/api/urls.py
index 1e564b29..2757f176 100644
--- a/pydis_site/apps/api/urls.py
+++ b/pydis_site/apps/api/urls.py
@@ -1,7 +1,7 @@
 from django.urls import include, path
 from rest_framework.routers import DefaultRouter
 
-from .views import HealthcheckView, RulesView
+from .views import GitHubArtifactsView, HealthcheckView, RulesView
 from .viewsets import (
     AocAccountLinkViewSet,
     AocCompletionistBlockViewSet,
@@ -86,5 +86,10 @@ urlpatterns = (
     # from django_hosts.resolvers import reverse
     path('bot/', include((bot_router.urls, 'api'), namespace='bot')),
     path('healthcheck', HealthcheckView.as_view(), name='healthcheck'),
-    path('rules', RulesView.as_view(), name='rules')
+    path('rules', RulesView.as_view(), name='rules'),
+    path(
+        'github/artifact/<str:owner>/<str:repo>/<str:sha>/<str:action_name>/<str:artifact_name>',
+        GitHubArtifactsView.as_view(),
+        name="github-artifacts"
+    ),
 )
diff --git a/pydis_site/apps/api/views.py b/pydis_site/apps/api/views.py
index 816463f6..ad2d948e 100644
--- a/pydis_site/apps/api/views.py
+++ b/pydis_site/apps/api/views.py
@@ -1,7 +1,10 @@
 from rest_framework.exceptions import ParseError
+from rest_framework.request import Request
 from rest_framework.response import Response
 from rest_framework.views import APIView
 
+from . import github_utils
+
 
 class HealthcheckView(APIView):
     """
@@ -152,3 +155,53 @@ class RulesView(APIView):
                 "Do not offer or ask for paid work of any kind."
             ),
         ])
+
+
+class GitHubArtifactsView(APIView):
+    """
+    Provides utilities for interacting with the GitHub API and obtaining action artifacts.
+
+    ## Routes
+    ### GET /github/artifacts
+    Returns a download URL for the artifact requested.
+
+        {
+            'url': 'https://pipelines.actions.githubusercontent.com/...'
+        }
+
+    ### Exceptions
+    In case of an error, the following body will be returned:
+
+        {
+            "error_type": "<error class name>",
+            "error": "<error description>",
+            "requested_resource": "<owner>/<repo>/<sha>/<artifact_name>"
+        }
+
+    ## Authentication
+    Does not require any authentication nor permissions.
+    """
+
+    authentication_classes = ()
+    permission_classes = ()
+
+    def get(
+        self,
+        request: Request,
+        *,
+        owner: str,
+        repo: str,
+        sha: str,
+        action_name: str,
+        artifact_name: str
+    ) -> Response:
+        """Return a download URL for the requested artifact."""
+        try:
+            url = github_utils.get_artifact(owner, repo, sha, action_name, artifact_name)
+            return Response({"url": url})
+        except github_utils.ArtifactProcessingError as e:
+            return Response({
+                "error_type": e.__class__.__name__,
+                "error": str(e),
+                "requested_resource": f"{owner}/{repo}/{sha}/{action_name}/{artifact_name}"
+            }, status=e.status)
-- 
cgit v1.2.3


From 26a3c19b53883015e8ba87db2a668c3eece2ce20 Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Tue, 12 Jul 2022 14:45:22 +0400
Subject: Make Awaiting Workflow Run A User Responsibility

Moves the responsibility of re-requesting a workflow run from the API to
the user. This makes the requests much shorter-lived, and allows the
client to control how they want to handle sleeping and retrying.

This also has the benefit of removing the only real piece of async code,
so now the view is completely sync once again.

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/api/github_utils.py            |  79 +++++------
 pydis_site/apps/api/tests/test_github_utils.py | 174 ++++++++++++-------------
 static-builds/netlify_build.py                 |   9 +-
 3 files changed, 131 insertions(+), 131 deletions(-)

(limited to 'pydis_site/apps/api')

diff --git a/pydis_site/apps/api/github_utils.py b/pydis_site/apps/api/github_utils.py
index 70dccdff..707b36e5 100644
--- a/pydis_site/apps/api/github_utils.py
+++ b/pydis_site/apps/api/github_utils.py
@@ -1,17 +1,17 @@
 """Utilities for working with the GitHub API."""
 
-import asyncio
 import datetime
 import math
 
 import httpx
 import jwt
-from asgiref.sync import async_to_sync
 
 from pydis_site import settings
 
-MAX_POLLS = 20
-"""The maximum number of attempts at fetching a workflow run."""
+MAX_RUN_TIME = datetime.timedelta(minutes=3)
+"""The maximum time allowed before an action is declared timed out."""
+ISO_FORMAT_STRING = "%Y-%m-%dT%H:%M:%SZ"
+"""The datetime string format GitHub uses."""
 
 
 class ArtifactProcessingError(Exception):
@@ -44,6 +44,12 @@ class RunTimeoutError(ArtifactProcessingError):
     status = 408
 
 
+class RunPendingError(ArtifactProcessingError):
+    """The requested workflow run is still pending, try again later."""
+
+    status = 202
+
+
 def generate_token() -> str:
     """
     Generate a JWT token to access the GitHub API.
@@ -66,7 +72,7 @@ def generate_token() -> str:
     )
 
 
-async def authorize(owner: str, repo: str) -> httpx.AsyncClient:
+def authorize(owner: str, repo: str) -> httpx.Client:
     """
     Get an access token for the requested repository.
 
@@ -75,7 +81,7 @@ async def authorize(owner: str, repo: str) -> httpx.AsyncClient:
         - POST <app_access_token> to get a token to access the given app
         - GET installation/repositories and check if the requested one is part of those
     """
-    client = httpx.AsyncClient(
+    client = httpx.Client(
         base_url=settings.GITHUB_API,
         headers={"Authorization": f"bearer {generate_token()}"},
         timeout=settings.TIMEOUT_PERIOD,
@@ -83,7 +89,7 @@ async def authorize(owner: str, repo: str) -> httpx.AsyncClient:
 
     try:
         # Get a list of app installations we have access to
-        apps = await client.get("app/installations")
+        apps = client.get("app/installations")
         apps.raise_for_status()
 
         for app in apps.json():
@@ -92,11 +98,11 @@ async def authorize(owner: str, repo: str) -> httpx.AsyncClient:
                 continue
 
             # Get the repositories of the specified owner
-            app_token = await client.post(app["access_tokens_url"])
+            app_token = client.post(app["access_tokens_url"])
             app_token.raise_for_status()
             client.headers["Authorization"] = f"bearer {app_token.json()['token']}"
 
-            repos = await client.get("installation/repositories")
+            repos = client.get("installation/repositories")
             repos.raise_for_status()
 
             # Search for the request repository
@@ -111,44 +117,39 @@ async def authorize(owner: str, repo: str) -> httpx.AsyncClient:
 
     except BaseException as e:
         # Close the client if we encountered an unexpected exception
-        await client.aclose()
+        client.close()
         raise e
 
 
-async def wait_for_run(client: httpx.AsyncClient, run: dict) -> str:
-    """Wait for the provided `run` to finish, and return the URL to its artifacts."""
-    polls = 0
-    while polls <= MAX_POLLS:
-        if run["status"] != "completed":
-            # The action is still processing, wait a bit longer
-            polls += 1
-            await asyncio.sleep(10)
-
-        elif run["conclusion"] != "success":
-            # The action failed, or did not run
-            raise ActionFailedError(f"The requested workflow ended with: {run['conclusion']}")
+def check_run_status(run: dict) -> str:
+    """Check if the provided run has been completed, otherwise raise an exception."""
+    created_at = datetime.datetime.strptime(run["created_at"], ISO_FORMAT_STRING)
+    run_time = datetime.datetime.now() - created_at
 
+    if run["status"] != "completed":
+        if run_time <= MAX_RUN_TIME:
+            raise RunPendingError(
+                f"The requested run is still pending. It was created "
+                f"{run_time.seconds // 60}:{run_time.seconds % 60 :>02} minutes ago."
+            )
         else:
-            # The desired action was found, and it ended successfully
-            return run["artifacts_url"]
+            raise RunTimeoutError("The requested workflow was not ready in time.")
 
-        run = await client.get(run["url"])
-        run.raise_for_status()
-        run = run.json()
+    if run["conclusion"] != "success":
+        # The action failed, or did not run
+        raise ActionFailedError(f"The requested workflow ended with: {run['conclusion']}")
 
-    raise RunTimeoutError("The requested workflow was not ready in time.")
+    # The requested action is ready
+    return run["artifacts_url"]
 
 
-@async_to_sync
-async def get_artifact(
-    owner: str, repo: str, sha: str, action_name: str, artifact_name: str
-) -> str:
+def get_artifact(owner: str, repo: str, sha: str, action_name: str, artifact_name: str) -> str:
     """Get a download URL for a build artifact."""
-    client = await authorize(owner, repo)
+    client = authorize(owner, repo)
 
     try:
         # Get the workflow runs for this repository
-        runs = await client.get(f"/repos/{owner}/{repo}/actions/runs", params={"per_page": 100})
+        runs = client.get(f"/repos/{owner}/{repo}/actions/runs", params={"per_page": 100})
         runs.raise_for_status()
         runs = runs.json()
 
@@ -161,16 +162,16 @@ async def get_artifact(
                 "Could not find a run matching the provided settings in the previous hundred runs."
             )
 
-        # Wait for the workflow to finish
-        url = await wait_for_run(client, run)
+        # Check the workflow status
+        url = check_run_status(run)
 
         # Filter the artifacts, and return the download URL
-        artifacts = await client.get(url)
+        artifacts = client.get(url)
         artifacts.raise_for_status()
 
         for artifact in artifacts.json()["artifacts"]:
             if artifact["name"] == artifact_name:
-                data = await client.get(artifact["archive_download_url"])
+                data = client.get(artifact["archive_download_url"])
                 if data.status_code == 302:
                     return str(data.next_request.url)
 
@@ -180,4 +181,4 @@ async def get_artifact(
         raise NotFoundError("Could not find an artifact matching the provided name.")
 
     finally:
-        await client.aclose()
+        client.close()
diff --git a/pydis_site/apps/api/tests/test_github_utils.py b/pydis_site/apps/api/tests/test_github_utils.py
index dc17d609..78f2979d 100644
--- a/pydis_site/apps/api/tests/test_github_utils.py
+++ b/pydis_site/apps/api/tests/test_github_utils.py
@@ -1,6 +1,4 @@
-import asyncio
 import datetime
-import random
 import unittest
 from unittest import mock
 
@@ -14,16 +12,6 @@ from django.urls import reverse
 from .. import github_utils
 
 
-def patched_raise_for_status(response: httpx.Response):
-    """Fake implementation of raise_for_status which does not need a request to be set."""
-    if response.status_code // 100 != 2:  # pragma: no cover
-        raise httpx.HTTPStatusError(
-            f"Non 2xx response code: {response.status_code}",
-            request=getattr(response, "_request", httpx.Request("GET", "")),
-            response=response
-        )
-
-
 class GeneralUtilityTests(unittest.TestCase):
     """Test the utility methods which do not fit in another class."""
 
@@ -51,53 +39,50 @@ class GeneralUtilityTests(unittest.TestCase):
         self.assertLess(decoded["exp"], (datetime.datetime.now() + delta).timestamp())
 
 
-@mock.patch("httpx.AsyncClient", autospec=True)
-@mock.patch("asyncio.sleep", new=mock.AsyncMock(return_value=asyncio.Future))
-@mock.patch("httpx.Response.raise_for_status", new=patched_raise_for_status)
-class WaitForTests(unittest.IsolatedAsyncioTestCase):
-    """Tests the wait_for utility."""
-
-    async def test_wait_for_successful_run(self, client_mock: mock.Mock):
-        """Test that the wait_for method handles successfully runs."""
-        final_url = "some_url" + str(random.randint(0, 10))
-
-        client_mock.get.side_effect = responses = [
-            httpx.Response(200, json={"status": "queued", "url": ""}),
-            httpx.Response(200, json={"status": "pending", "url": ""}),
-            httpx.Response(200, json={
-                "status": "completed",
-                "conclusion": "success",
-                "url": "",
-                "artifacts_url": final_url
-            })
-        ]
+class WaitForTests(unittest.TestCase):
+    """Tests the check_run_status utility."""
 
-        result = await github_utils.wait_for_run(client_mock, responses[0].json())
-        self.assertEqual(final_url, result)
+    def test_completed_run(self):
+        final_url = "some_url_string_1234"
 
-    async def test_wait_for_failed_run(self, client_mock: mock.Mock):
-        """Test that the wait_for method handles failed runs."""
-        client_mock.get.return_value = httpx.Response(200, json={
+        result = github_utils.check_run_status({
             "status": "completed",
-            "conclusion": "failed",
+            "conclusion": "success",
+            "created_at": datetime.datetime.now().strftime(github_utils.ISO_FORMAT_STRING),
+            "artifacts_url": final_url,
         })
+        self.assertEqual(final_url, result)
 
-        with self.assertRaises(github_utils.ActionFailedError):
-            await github_utils.wait_for_run(client_mock, {"status": "pending", "url": ""})
+    def test_pending_run(self):
+        """Test that a pending run raises the proper exception."""
+        with self.assertRaises(github_utils.RunPendingError):
+            github_utils.check_run_status({
+                "status": "pending",
+                "created_at": datetime.datetime.now().strftime(github_utils.ISO_FORMAT_STRING),
+            })
 
-    async def test_wait_for_timeout(self, client_mock: mock.Mock):
-        """Test that the wait_for method quits after a few attempts."""
-        client_mock.get.side_effect = responses = [
-            httpx.Response(200, json={"status": "pending", "url": ""})
-        ] * (github_utils.MAX_POLLS + 5)
+    def test_timeout_error(self):
+        """Test that a timeout is declared after a certain duration."""
+        # Set the creation time to well before the MAX_RUN_TIME
+        # to guarantee the right conclusion
+        created = (
+            datetime.datetime.now() - github_utils.MAX_RUN_TIME - datetime.timedelta(minutes=10)
+        ).strftime(github_utils.ISO_FORMAT_STRING)
 
         with self.assertRaises(github_utils.RunTimeoutError):
-            await github_utils.wait_for_run(client_mock, responses[0].json())
+            github_utils.check_run_status({"status": "pending", "created_at": created})
+
+    def test_failed_run(self):
+        """Test that a failed run raises the proper exception."""
+        with self.assertRaises(github_utils.ActionFailedError):
+            github_utils.check_run_status({
+                "status": "completed",
+                "conclusion": "failed",
+                "created_at": datetime.datetime.now().strftime(github_utils.ISO_FORMAT_STRING),
+            })
 
 
-async def get_response_authorize(
-    _: httpx.AsyncClient, request: httpx.Request, **__
-) -> httpx.Response:
+def get_response_authorize(_: httpx.Client, request: httpx.Request, **__) -> httpx.Response:
     """
     Helper method for the authorize tests.
 
@@ -141,76 +126,83 @@ async def get_response_authorize(
     return httpx.Response(500, request=request)  # pragma: no cover
 
 
-@mock.patch("httpx.AsyncClient.send", new=get_response_authorize)
+@mock.patch("httpx.Client.send", new=get_response_authorize)
 @mock.patch.object(github_utils, "generate_token", new=mock.Mock(return_value="JWT initial token"))
-class AuthorizeTests(unittest.IsolatedAsyncioTestCase):
+class AuthorizeTests(unittest.TestCase):
     """Test the authorize utility."""
 
-    async def test_invalid_apps_auth(self):
+    def test_invalid_apps_auth(self):
         """Test that an exception is raised if authorization was attempted with an invalid token."""
         with mock.patch.object(github_utils, "generate_token", return_value="Invalid token"):
             with self.assertRaises(httpx.HTTPStatusError) as error:
-                await github_utils.authorize("VALID_OWNER", "VALID_REPO")
+                github_utils.authorize("VALID_OWNER", "VALID_REPO")
 
         exception: httpx.HTTPStatusError = error.exception
         self.assertEqual(401, exception.response.status_code)
         self.assertEqual("auth app/installations", exception.response.json()["error"])
 
-    async def test_missing_repo(self):
+    def test_missing_repo(self):
         """Test that an exception is raised when the selected owner or repo are not available."""
         with self.assertRaises(github_utils.NotFoundError):
-            await github_utils.authorize("INVALID_OWNER", "VALID_REPO")
+            github_utils.authorize("INVALID_OWNER", "VALID_REPO")
         with self.assertRaises(github_utils.NotFoundError):
-            await github_utils.authorize("VALID_OWNER", "INVALID_REPO")
+            github_utils.authorize("VALID_OWNER", "INVALID_REPO")
 
-    async def test_valid_authorization(self):
+    def test_valid_authorization(self):
         """Test that an accessible repository can be accessed."""
-        client = await github_utils.authorize("VALID_OWNER", "VALID_REPO")
+        client = github_utils.authorize("VALID_OWNER", "VALID_REPO")
         self.assertEqual("bearer app access token", client.headers.get("Authorization"))
 
 
-async def get_response_get_artifact(request: httpx.Request, **_) -> httpx.Response:
-    """
-    Helper method for the get_artifact tests.
+class ArtifactFetcherTests(unittest.TestCase):
+    """Test the get_artifact utility."""
 
-    Requests are intercepted before being sent out, and the appropriate responses are returned.
-    """
-    path = request.url.path
+    @staticmethod
+    def get_response_get_artifact(request: httpx.Request, **_) -> httpx.Response:
+        """
+        Helper method for the get_artifact tests.
 
-    if "force_error" in path:
-        return httpx.Response(404, request=request)
+        Requests are intercepted before being sent out, and the appropriate responses are returned.
+        """
+        path = request.url.path
 
-    if request.method == "GET":
-        if path == "/repos/owner/repo/actions/runs":
-            return httpx.Response(200, request=request, json={"workflow_runs": [{
-                "name": "action_name",
-                "head_sha": "action_sha"
-            }]})
-        elif path == "/artifact_url":
-            return httpx.Response(200, request=request, json={"artifacts": [{
-                "name": "artifact_name",
-                "archive_download_url": "artifact_download_url"
-            }]})
-        elif path == "/artifact_download_url":
-            response = httpx.Response(302, request=request)
-            response.next_request = httpx.Request("GET", httpx.URL("https://final_download.url"))
-            return response
-
-    # Reaching this point means something has gone wrong
-    return httpx.Response(500, request=request)  # pragma: no cover
+        if "force_error" in path:
+            return httpx.Response(404, request=request)
 
+        if request.method == "GET":
+            if path == "/repos/owner/repo/actions/runs":
+                return httpx.Response(
+                    200, request=request, json={"workflow_runs": [{
+                        "name": "action_name",
+                        "head_sha": "action_sha"
+                    }]}
+                )
+            elif path == "/artifact_url":
+                return httpx.Response(
+                    200, request=request, json={"artifacts": [{
+                        "name": "artifact_name",
+                        "archive_download_url": "artifact_download_url"
+                    }]}
+                )
+            elif path == "/artifact_download_url":
+                response = httpx.Response(302, request=request)
+                response.next_request = httpx.Request(
+                    "GET",
+                    httpx.URL("https://final_download.url")
+                )
+                return response
 
-class ArtifactFetcherTests(unittest.IsolatedAsyncioTestCase):
-    """Test the get_artifact utility."""
+        # Reaching this point means something has gone wrong
+        return httpx.Response(500, request=request)  # pragma: no cover
 
     def setUp(self) -> None:
         self.call_args = ["owner", "repo", "action_sha", "action_name", "artifact_name"]
-        self.client = httpx.AsyncClient(base_url="https://example.com")
+        self.client = httpx.Client(base_url="https://example.com")
 
         self.patchers = [
-            mock.patch.object(self.client, "send", new=get_response_get_artifact),
+            mock.patch.object(self.client, "send", new=self.get_response_get_artifact),
             mock.patch.object(github_utils, "authorize", return_value=self.client),
-            mock.patch.object(github_utils, "wait_for_run", return_value="artifact_url"),
+            mock.patch.object(github_utils, "check_run_status", return_value="artifact_url"),
         ]
 
         for patcher in self.patchers:
@@ -266,7 +258,7 @@ class GitHubArtifactViewTests(django.test.TestCase):
         }
         cls.url = reverse("api:github-artifacts", kwargs=cls.kwargs)
 
-    async def test_successful(self, artifact_mock: mock.Mock):
+    def test_successful(self, artifact_mock: mock.Mock):
         """Test a proper response is returned with proper input."""
         artifact_mock.return_value = "final download url"
         result = self.client.get(self.url)
@@ -274,7 +266,7 @@ class GitHubArtifactViewTests(django.test.TestCase):
         self.assertIsInstance(result, rest_framework.response.Response)
         self.assertEqual({"url": artifact_mock.return_value}, result.data)
 
-    async def test_failed_fetch(self, artifact_mock: mock.Mock):
+    def test_failed_fetch(self, artifact_mock: mock.Mock):
         """Test that a proper error is returned when the request fails."""
         artifact_mock.side_effect = github_utils.NotFoundError("Test error message")
         result = self.client.get(self.url)
diff --git a/static-builds/netlify_build.py b/static-builds/netlify_build.py
index 13cd0279..a473bd91 100644
--- a/static-builds/netlify_build.py
+++ b/static-builds/netlify_build.py
@@ -8,6 +8,7 @@
 
 import json
 import os
+import time
 import zipfile
 from pathlib import Path
 from urllib import parse
@@ -29,7 +30,7 @@ if __name__ == "__main__":
     print(f"Fetching download URL from {download_url}")
     response = httpx.get(download_url, follow_redirects=True)
 
-    if response.status_code != 200:
+    if response.status_code // 100 != 2:
         try:
             print(response.json())
         except json.JSONDecodeError:
@@ -37,6 +38,12 @@ if __name__ == "__main__":
 
         response.raise_for_status()
 
+    # The workflow is still pending, retry in a bit
+    while response.status_code == 202:
+        print(f"{response.json()['error']}. Retrying in 10 seconds.")
+        time.sleep(10)
+        response = httpx.get(download_url, follow_redirects=True)
+
     url = response.json()["url"]
     print(f"Downloading build from {url}")
     zipped_content = httpx.get(url, follow_redirects=True)
-- 
cgit v1.2.3


From 124c84b9e4f8195485b6ff9b3896cc87e640e02b Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Thu, 14 Jul 2022 05:57:05 +0400
Subject: Clean Up Artifact Tests

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/api/tests/test_github_utils.py | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

(limited to 'pydis_site/apps/api')

diff --git a/pydis_site/apps/api/tests/test_github_utils.py b/pydis_site/apps/api/tests/test_github_utils.py
index 78f2979d..a9eab9a5 100644
--- a/pydis_site/apps/api/tests/test_github_utils.py
+++ b/pydis_site/apps/api/tests/test_github_utils.py
@@ -21,7 +21,7 @@ class GeneralUtilityTests(unittest.TestCase):
             """
             Intercept the encode method.
 
-            It is performed with an algorithm which does not require a PEM key, as it may
+            The result is encoded with an algorithm which does not require a PEM key, as it may
             not be available in testing environments.
             """
             self.assertEqual("RS256", algorithm, "The GitHub App JWT must be signed using RS256.")
@@ -39,10 +39,11 @@ class GeneralUtilityTests(unittest.TestCase):
         self.assertLess(decoded["exp"], (datetime.datetime.now() + delta).timestamp())
 
 
-class WaitForTests(unittest.TestCase):
+class CheckRunTests(unittest.TestCase):
     """Tests the check_run_status utility."""
 
     def test_completed_run(self):
+        """Test that an already completed run returns the correct URL."""
         final_url = "some_url_string_1234"
 
         result = github_utils.check_run_status({
@@ -245,20 +246,17 @@ class ArtifactFetcherTests(unittest.TestCase):
 class GitHubArtifactViewTests(django.test.TestCase):
     """Test the GitHub artifact fetch API view."""
 
-    @classmethod
-    def setUpClass(cls):
-        super().setUpClass()
-
-        cls.kwargs = {
+    def setUp(self):
+        self.kwargs = {
             "owner": "test_owner",
             "repo": "test_repo",
             "sha": "test_sha",
             "action_name": "test_action",
             "artifact_name": "test_artifact",
         }
-        cls.url = reverse("api:github-artifacts", kwargs=cls.kwargs)
+        self.url = reverse("api:github-artifacts", kwargs=self.kwargs)
 
-    def test_successful(self, artifact_mock: mock.Mock):
+    def test_correct_artifact(self, artifact_mock: mock.Mock):
         """Test a proper response is returned with proper input."""
         artifact_mock.return_value = "final download url"
         result = self.client.get(self.url)
-- 
cgit v1.2.3


From 37001bca59c1d3d5fc8a8dadffda00d55fc9e0b6 Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Sun, 24 Jul 2022 08:32:43 +0200
Subject: Use Dataclass For Workflow Run

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/api/github_utils.py            | 41 ++++++++++++++++-----
 pydis_site/apps/api/tests/test_github_utils.py | 50 +++++++++++++++-----------
 2 files changed, 62 insertions(+), 29 deletions(-)

(limited to 'pydis_site/apps/api')

diff --git a/pydis_site/apps/api/github_utils.py b/pydis_site/apps/api/github_utils.py
index 707b36e5..c4ace6b7 100644
--- a/pydis_site/apps/api/github_utils.py
+++ b/pydis_site/apps/api/github_utils.py
@@ -1,7 +1,8 @@
 """Utilities for working with the GitHub API."""
-
+import dataclasses
 import datetime
 import math
+import typing
 
 import httpx
 import jwt
@@ -50,6 +51,29 @@ class RunPendingError(ArtifactProcessingError):
     status = 202
 
 
+@dataclasses.dataclass(frozen=True)
+class WorkflowRun:
+    """
+    A workflow run from the GitHub API.
+
+    https://docs.github.com/en/rest/actions/workflow-runs#get-a-workflow-run
+    """
+
+    name: str
+    head_sha: str
+    created_at: str
+    status: str
+    conclusion: str
+    artifacts_url: str
+
+    @classmethod
+    def from_raw(cls, data: dict[str, typing.Any]):
+        """Create an instance using the raw data from the API, discarding unused fields."""
+        return cls(**{
+            key.name: data[key.name] for key in dataclasses.fields(cls)
+        })
+
+
 def generate_token() -> str:
     """
     Generate a JWT token to access the GitHub API.
@@ -121,12 +145,12 @@ def authorize(owner: str, repo: str) -> httpx.Client:
         raise e
 
 
-def check_run_status(run: dict) -> str:
+def check_run_status(run: WorkflowRun) -> str:
     """Check if the provided run has been completed, otherwise raise an exception."""
-    created_at = datetime.datetime.strptime(run["created_at"], ISO_FORMAT_STRING)
+    created_at = datetime.datetime.strptime(run.created_at, ISO_FORMAT_STRING)
     run_time = datetime.datetime.now() - created_at
 
-    if run["status"] != "completed":
+    if run.status != "completed":
         if run_time <= MAX_RUN_TIME:
             raise RunPendingError(
                 f"The requested run is still pending. It was created "
@@ -135,12 +159,12 @@ def check_run_status(run: dict) -> str:
         else:
             raise RunTimeoutError("The requested workflow was not ready in time.")
 
-    if run["conclusion"] != "success":
+    if run.conclusion != "success":
         # The action failed, or did not run
-        raise ActionFailedError(f"The requested workflow ended with: {run['conclusion']}")
+        raise ActionFailedError(f"The requested workflow ended with: {run.conclusion}")
 
     # The requested action is ready
-    return run["artifacts_url"]
+    return run.artifacts_url
 
 
 def get_artifact(owner: str, repo: str, sha: str, action_name: str, artifact_name: str) -> str:
@@ -155,7 +179,8 @@ def get_artifact(owner: str, repo: str, sha: str, action_name: str, artifact_nam
 
         # Filter the runs for the one associated with the given SHA
         for run in runs["workflow_runs"]:
-            if run["name"] == action_name and sha == run["head_sha"]:
+            run = WorkflowRun.from_raw(run)
+            if run.name == action_name and sha == run.head_sha:
                 break
         else:
             raise NotFoundError(
diff --git a/pydis_site/apps/api/tests/test_github_utils.py b/pydis_site/apps/api/tests/test_github_utils.py
index a9eab9a5..f5e072a9 100644
--- a/pydis_site/apps/api/tests/test_github_utils.py
+++ b/pydis_site/apps/api/tests/test_github_utils.py
@@ -1,4 +1,6 @@
+import dataclasses
 import datetime
+import typing
 import unittest
 from unittest import mock
 
@@ -42,45 +44,46 @@ class GeneralUtilityTests(unittest.TestCase):
 class CheckRunTests(unittest.TestCase):
     """Tests the check_run_status utility."""
 
+    run_kwargs: typing.Mapping = {
+        "name": "run_name",
+        "head_sha": "sha",
+        "status": "completed",
+        "conclusion": "success",
+        "created_at": datetime.datetime.now().strftime(github_utils.ISO_FORMAT_STRING),
+        "artifacts_url": "url",
+    }
+
     def test_completed_run(self):
         """Test that an already completed run returns the correct URL."""
         final_url = "some_url_string_1234"
 
-        result = github_utils.check_run_status({
-            "status": "completed",
-            "conclusion": "success",
-            "created_at": datetime.datetime.now().strftime(github_utils.ISO_FORMAT_STRING),
-            "artifacts_url": final_url,
-        })
+        kwargs = dict(self.run_kwargs, artifacts_url=final_url)
+        result = github_utils.check_run_status(github_utils.WorkflowRun(**kwargs))
         self.assertEqual(final_url, result)
 
     def test_pending_run(self):
         """Test that a pending run raises the proper exception."""
+        kwargs = dict(self.run_kwargs, status="pending")
         with self.assertRaises(github_utils.RunPendingError):
-            github_utils.check_run_status({
-                "status": "pending",
-                "created_at": datetime.datetime.now().strftime(github_utils.ISO_FORMAT_STRING),
-            })
+            github_utils.check_run_status(github_utils.WorkflowRun(**kwargs))
 
     def test_timeout_error(self):
         """Test that a timeout is declared after a certain duration."""
+        kwargs = dict(self.run_kwargs, status="pending")
         # Set the creation time to well before the MAX_RUN_TIME
         # to guarantee the right conclusion
-        created = (
+        kwargs["created_at"] = (
             datetime.datetime.now() - github_utils.MAX_RUN_TIME - datetime.timedelta(minutes=10)
         ).strftime(github_utils.ISO_FORMAT_STRING)
 
         with self.assertRaises(github_utils.RunTimeoutError):
-            github_utils.check_run_status({"status": "pending", "created_at": created})
+            github_utils.check_run_status(github_utils.WorkflowRun(**kwargs))
 
     def test_failed_run(self):
         """Test that a failed run raises the proper exception."""
+        kwargs = dict(self.run_kwargs, conclusion="failed")
         with self.assertRaises(github_utils.ActionFailedError):
-            github_utils.check_run_status({
-                "status": "completed",
-                "conclusion": "failed",
-                "created_at": datetime.datetime.now().strftime(github_utils.ISO_FORMAT_STRING),
-            })
+            github_utils.check_run_status(github_utils.WorkflowRun(**kwargs))
 
 
 def get_response_authorize(_: httpx.Client, request: httpx.Request, **__) -> httpx.Response:
@@ -172,11 +175,16 @@ class ArtifactFetcherTests(unittest.TestCase):
 
         if request.method == "GET":
             if path == "/repos/owner/repo/actions/runs":
+                run = github_utils.WorkflowRun(
+                    name="action_name",
+                    head_sha="action_sha",
+                    created_at=datetime.datetime.now().strftime(github_utils.ISO_FORMAT_STRING),
+                    status="completed",
+                    conclusion="success",
+                    artifacts_url="artifacts_url"
+                )
                 return httpx.Response(
-                    200, request=request, json={"workflow_runs": [{
-                        "name": "action_name",
-                        "head_sha": "action_sha"
-                    }]}
+                    200, request=request, json={"workflow_runs": [dataclasses.asdict(run)]}
                 )
             elif path == "/artifact_url":
                 return httpx.Response(
-- 
cgit v1.2.3


From f16d3b1b1d14cdf0de1e56ae2bc466152e930f34 Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Sun, 24 Jul 2022 10:06:47 +0200
Subject: Use UTC Time For GitHub API

When reading the created_at time from the GitHub API, it'll be a naive
date string with UTC time, so we use that instead of the system's time.

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/api/github_utils.py            | 2 +-
 pydis_site/apps/api/tests/test_github_utils.py | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'pydis_site/apps/api')

diff --git a/pydis_site/apps/api/github_utils.py b/pydis_site/apps/api/github_utils.py
index c4ace6b7..7d26b147 100644
--- a/pydis_site/apps/api/github_utils.py
+++ b/pydis_site/apps/api/github_utils.py
@@ -148,7 +148,7 @@ def authorize(owner: str, repo: str) -> httpx.Client:
 def check_run_status(run: WorkflowRun) -> str:
     """Check if the provided run has been completed, otherwise raise an exception."""
     created_at = datetime.datetime.strptime(run.created_at, ISO_FORMAT_STRING)
-    run_time = datetime.datetime.now() - created_at
+    run_time = datetime.datetime.utcnow() - created_at
 
     if run.status != "completed":
         if run_time <= MAX_RUN_TIME:
diff --git a/pydis_site/apps/api/tests/test_github_utils.py b/pydis_site/apps/api/tests/test_github_utils.py
index f5e072a9..f642f689 100644
--- a/pydis_site/apps/api/tests/test_github_utils.py
+++ b/pydis_site/apps/api/tests/test_github_utils.py
@@ -49,7 +49,7 @@ class CheckRunTests(unittest.TestCase):
         "head_sha": "sha",
         "status": "completed",
         "conclusion": "success",
-        "created_at": datetime.datetime.now().strftime(github_utils.ISO_FORMAT_STRING),
+        "created_at": datetime.datetime.utcnow().strftime(github_utils.ISO_FORMAT_STRING),
         "artifacts_url": "url",
     }
 
@@ -73,7 +73,7 @@ class CheckRunTests(unittest.TestCase):
         # Set the creation time to well before the MAX_RUN_TIME
         # to guarantee the right conclusion
         kwargs["created_at"] = (
-            datetime.datetime.now() - github_utils.MAX_RUN_TIME - datetime.timedelta(minutes=10)
+            datetime.datetime.utcnow() - github_utils.MAX_RUN_TIME - datetime.timedelta(minutes=10)
         ).strftime(github_utils.ISO_FORMAT_STRING)
 
         with self.assertRaises(github_utils.RunTimeoutError):
-- 
cgit v1.2.3


From dfc32e28103d652170868d09b49ba98ea95c91bf Mon Sep 17 00:00:00 2001
From: Chris Lovering <chris.lovering.95@gmail.com>
Date: Wed, 27 Jul 2022 21:33:13 +0100
Subject: Add a field to track the time an infraction was last applied

A default is set for backwards compatibility with bot version that don't explicitly give a value.
---
 .../api/migrations/0084_infraction_last_applied.py    | 19 +++++++++++++++++++
 pydis_site/apps/api/models/bot/infraction.py          |  6 ++++++
 2 files changed, 25 insertions(+)
 create mode 100644 pydis_site/apps/api/migrations/0084_infraction_last_applied.py

(limited to 'pydis_site/apps/api')

diff --git a/pydis_site/apps/api/migrations/0084_infraction_last_applied.py b/pydis_site/apps/api/migrations/0084_infraction_last_applied.py
new file mode 100644
index 00000000..0977fa20
--- /dev/null
+++ b/pydis_site/apps/api/migrations/0084_infraction_last_applied.py
@@ -0,0 +1,19 @@
+# Generated by Django 4.0.6 on 2022-07-27 20:32
+
+from django.db import migrations, models
+import django.utils.timezone
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('api', '0083_remove_embed_validation'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='infraction',
+            name='last_applied',
+            field=models.DateTimeField(default=django.utils.timezone.now, help_text='The date and time of when this infraction was last applied.'),
+        ),
+    ]
diff --git a/pydis_site/apps/api/models/bot/infraction.py b/pydis_site/apps/api/models/bot/infraction.py
index c9303024..218ee5ec 100644
--- a/pydis_site/apps/api/models/bot/infraction.py
+++ b/pydis_site/apps/api/models/bot/infraction.py
@@ -23,6 +23,12 @@ class Infraction(ModelReprMixin, models.Model):
         default=timezone.now,
         help_text="The date and time of the creation of this infraction."
     )
+    last_applied = models.DateTimeField(
+        # This default is for backwards compatibility with bot versions
+        # that don't explicitly give a value.
+        default=timezone.now,
+        help_text="The date and time of when this infraction was last applied."
+    )
     expires_at = models.DateTimeField(
         null=True,
         help_text=(
-- 
cgit v1.2.3


From 163201d27fa7505632a36a3d918ebb9321856554 Mon Sep 17 00:00:00 2001
From: Chris Lovering <chris.lovering.95@gmail.com>
Date: Wed, 27 Jul 2022 22:31:09 +0100
Subject: Backdate last_applied dates to use value of inserted_at

---
 pydis_site/apps/api/migrations/0084_infraction_last_applied.py | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

(limited to 'pydis_site/apps/api')

diff --git a/pydis_site/apps/api/migrations/0084_infraction_last_applied.py b/pydis_site/apps/api/migrations/0084_infraction_last_applied.py
index 0977fa20..7704ddb8 100644
--- a/pydis_site/apps/api/migrations/0084_infraction_last_applied.py
+++ b/pydis_site/apps/api/migrations/0084_infraction_last_applied.py
@@ -1,7 +1,13 @@
 # Generated by Django 4.0.6 on 2022-07-27 20:32
 
-from django.db import migrations, models
 import django.utils.timezone
+from django.db import migrations, models
+from django.apps.registry import Apps
+
+
+def set_last_applied_to_inserted_at(apps: Apps, schema_editor):
+    Infractions = apps.get_model("api", "infraction")
+    Infractions.objects.all().update(last_applied=models.F("inserted_at"))
 
 
 class Migration(migrations.Migration):
@@ -16,4 +22,5 @@ class Migration(migrations.Migration):
             name='last_applied',
             field=models.DateTimeField(default=django.utils.timezone.now, help_text='The date and time of when this infraction was last applied.'),
         ),
+        migrations.RunPython(set_last_applied_to_inserted_at)
     ]
-- 
cgit v1.2.3


From 562b6f0d783583838e51a86086aa441f093de102 Mon Sep 17 00:00:00 2001
From: ionite34 <dev@ionite.io>
Date: Wed, 3 Aug 2022 17:15:05 -0400
Subject: Added `last_applied` to `serializers`

---
 pydis_site/apps/api/serializers.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'pydis_site/apps/api')

diff --git a/pydis_site/apps/api/serializers.py b/pydis_site/apps/api/serializers.py
index e53ccffa..9228c1f4 100644
--- a/pydis_site/apps/api/serializers.py
+++ b/pydis_site/apps/api/serializers.py
@@ -176,6 +176,7 @@ class InfractionSerializer(ModelSerializer):
         fields = (
             'id',
             'inserted_at',
+            'last_applied',
             'expires_at',
             'active',
             'user',
-- 
cgit v1.2.3


From 460ccffe266373febcd1676d609d65f03de5a967 Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Fri, 12 Aug 2022 16:32:59 +0200
Subject: Rename GitHub App Environment Variables

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/api/github_utils.py |  4 ++--
 pydis_site/settings.py              | 12 ++++++------
 2 files changed, 8 insertions(+), 8 deletions(-)

(limited to 'pydis_site/apps/api')

diff --git a/pydis_site/apps/api/github_utils.py b/pydis_site/apps/api/github_utils.py
index 7d26b147..ad24165d 100644
--- a/pydis_site/apps/api/github_utils.py
+++ b/pydis_site/apps/api/github_utils.py
@@ -89,9 +89,9 @@ def generate_token() -> str:
         {
             "iat": math.floor((now - datetime.timedelta(seconds=60)).timestamp()),  # Issued at
             "exp": math.floor((now + datetime.timedelta(minutes=9)).timestamp()),  # Expires at
-            "iss": settings.GITHUB_OAUTH_APP_ID,
+            "iss": settings.GITHUB_APP_ID,
         },
-        settings.GITHUB_OAUTH_KEY,
+        settings.GITHUB_APP_KEY,
         algorithm="RS256"
     )
 
diff --git a/pydis_site/settings.py b/pydis_site/settings.py
index f382b052..bbf1d3aa 100644
--- a/pydis_site/settings.py
+++ b/pydis_site/settings.py
@@ -29,19 +29,19 @@ env = environ.Env(
     GIT_SHA=(str, 'development'),
     TIMEOUT_PERIOD=(int, 5),
     GITHUB_TOKEN=(str, None),
-    GITHUB_OAUTH_APP_ID=(str, None),
-    GITHUB_OAUTH_KEY=(str, None),
+    GITHUB_APP_ID=(str, None),
+    GITHUB_APP_KEY=(str, None),
 )
 
 GIT_SHA = env("GIT_SHA")
 GITHUB_API = "https://api.github.com"
 GITHUB_TOKEN = env("GITHUB_TOKEN")
-GITHUB_OAUTH_APP_ID = env("GITHUB_OAUTH_APP_ID")
-GITHUB_OAUTH_KEY = env("GITHUB_OAUTH_KEY")
+GITHUB_APP_ID = env("GITHUB_APP_ID")
+GITHUB_APP_KEY = env("GITHUB_APP_KEY")
 
-if GITHUB_OAUTH_KEY and (oauth_file := Path(GITHUB_OAUTH_KEY)).is_file():
+if GITHUB_APP_KEY and (key_file := Path(GITHUB_APP_KEY)).is_file():
     # Allow the OAuth key to be loaded from a file
-    GITHUB_OAUTH_KEY = oauth_file.read_text(encoding="utf-8")
+    GITHUB_APP_KEY = key_file.read_text(encoding="utf-8")
 
 sentry_sdk.init(
     dsn=env('SITE_DSN'),
-- 
cgit v1.2.3


From 79fee144823ce642a48af038398478144146730c Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Fri, 12 Aug 2022 22:54:17 +0200
Subject: Bump Deadline For GitHub Artifacts Route

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/api/github_utils.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pydis_site/apps/api')

diff --git a/pydis_site/apps/api/github_utils.py b/pydis_site/apps/api/github_utils.py
index ad24165d..5d7bcdc3 100644
--- a/pydis_site/apps/api/github_utils.py
+++ b/pydis_site/apps/api/github_utils.py
@@ -9,7 +9,7 @@ import jwt
 
 from pydis_site import settings
 
-MAX_RUN_TIME = datetime.timedelta(minutes=3)
+MAX_RUN_TIME = datetime.timedelta(minutes=10)
 """The maximum time allowed before an action is declared timed out."""
 ISO_FORMAT_STRING = "%Y-%m-%dT%H:%M:%SZ"
 """The datetime string format GitHub uses."""
-- 
cgit v1.2.3


From 25db8f564c0f5c473b165ccab14413ca4471ac7d Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Sun, 14 Aug 2022 07:20:34 +0200
Subject: Explicitly Specify Infraction Time In Tests

The infraction tests checked that the route returned infractions in the
correct order, which is based on insertion time. This can be fragile
however, since the insertion time can be very close (or identical)
during the tests. That became especially more likely with PR #741
(commit 149e67b4) which improved database access speed.

This is fixed by explicitly specifying the insertion time, and spacing
them out properly.

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/api/tests/test_infractions.py | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

(limited to 'pydis_site/apps/api')

diff --git a/pydis_site/apps/api/tests/test_infractions.py b/pydis_site/apps/api/tests/test_infractions.py
index f1107734..89ee4e23 100644
--- a/pydis_site/apps/api/tests/test_infractions.py
+++ b/pydis_site/apps/api/tests/test_infractions.py
@@ -56,15 +56,17 @@ class InfractionTests(AuthenticatedAPITestCase):
             type='ban',
             reason='He terk my jerb!',
             hidden=True,
+            inserted_at=dt(2020, 10, 10, 0, 0, 0, tzinfo=timezone.utc),
             expires_at=dt(5018, 11, 20, 15, 52, tzinfo=timezone.utc),
-            active=True
+            active=True,
         )
         cls.ban_inactive = Infraction.objects.create(
             user_id=cls.user.id,
             actor_id=cls.user.id,
             type='ban',
             reason='James is an ass, and we won\'t be working with him again.',
-            active=False
+            active=False,
+            inserted_at=dt(2020, 10, 10, 0, 1, 0, tzinfo=timezone.utc),
         )
         cls.mute_permanent = Infraction.objects.create(
             user_id=cls.user.id,
@@ -72,7 +74,8 @@ class InfractionTests(AuthenticatedAPITestCase):
             type='mute',
             reason='He has a filthy mouth and I am his soap.',
             active=True,
-            expires_at=None
+            inserted_at=dt(2020, 10, 10, 0, 2, 0, tzinfo=timezone.utc),
+            expires_at=None,
         )
         cls.superstar_expires_soon = Infraction.objects.create(
             user_id=cls.user.id,
@@ -80,7 +83,8 @@ class InfractionTests(AuthenticatedAPITestCase):
             type='superstar',
             reason='This one doesn\'t matter anymore.',
             active=True,
-            expires_at=dt.now(timezone.utc) + datetime.timedelta(hours=5)
+            inserted_at=dt(2020, 10, 10, 0, 3, 0, tzinfo=timezone.utc),
+            expires_at=dt.now(timezone.utc) + datetime.timedelta(hours=5),
         )
         cls.voiceban_expires_later = Infraction.objects.create(
             user_id=cls.user.id,
@@ -88,7 +92,8 @@ class InfractionTests(AuthenticatedAPITestCase):
             type='voice_ban',
             reason='Jet engine mic',
             active=True,
-            expires_at=dt.now(timezone.utc) + datetime.timedelta(days=5)
+            inserted_at=dt(2020, 10, 10, 0, 4, 0, tzinfo=timezone.utc),
+            expires_at=dt.now(timezone.utc) + datetime.timedelta(days=5),
         )
 
     def test_list_all(self):
-- 
cgit v1.2.3


From c0823236d20e801550fccdbb021d8aabb56d59c0 Mon Sep 17 00:00:00 2001
From: Amrou Bellalouna <Amrou.bellalouna@expensya.com>
Date: Thu, 18 Aug 2022 16:58:08 +0100
Subject: add collection of keywords per rule

In reference to issue #2108, this commit aims to add an initial set of keywords per rule.

These keywords will be later in the "rule" bot command in order to make rule identification easier
---
 pydis_site/apps/api/views.py | 27 ++++++++++++++++++---------
 1 file changed, 18 insertions(+), 9 deletions(-)

(limited to 'pydis_site/apps/api')

diff --git a/pydis_site/apps/api/views.py b/pydis_site/apps/api/views.py
index ad2d948e..f96d6a8d 100644
--- a/pydis_site/apps/api/views.py
+++ b/pydis_site/apps/api/views.py
@@ -124,35 +124,44 @@ class RulesView(APIView):
 
         return Response([
             (
-                f"Follow the {pydis_coc}."
+                f"Follow the {pydis_coc}.",
+                {"coc", "conduct", "code"}
             ),
             (
-                f"Follow the {discord_community_guidelines} and {discord_tos}."
+                f"Follow the {discord_community_guidelines} and {discord_tos}.",
+                {"guidelines", "discord_tos"}
             ),
             (
-                "Respect staff members and listen to their instructions."
+                "Respect staff members and listen to their instructions.",
+                {"staff", "instructions"}
             ),
             (
                 "Use English to the best of your ability. "
-                "Be polite if someone speaks English imperfectly."
+                "Be polite if someone speaks English imperfectly.",
+                {"english", "language"}
             ),
             (
                 "Do not provide or request help on projects that may break laws, "
-                "breach terms of services, or are malicious or inappropriate."
+                "breach terms of services, or are malicious or inappropriate.",
+                {"infraction", "tos", "breach", "malicious", "inappropriate"}
             ),
             (
-                "Do not post unapproved advertising."
+                "Do not post unapproved advertising.",
+                {"ads", "advertising"}
             ),
             (
                 "Keep discussions relevant to the channel topic. "
-                "Each channel's description tells you the topic."
+                "Each channel's description tells you the topic.",
+                {"off-topic", "topic", "relevance"}
             ),
             (
                 "Do not help with ongoing exams. When helping with homework, "
-                "help people learn how to do the assignment without doing it for them."
+                "help people learn how to do the assignment without doing it for them.",
+                {"exams", "assignment", "assignments", "homework"}
             ),
             (
-                "Do not offer or ask for paid work of any kind."
+                "Do not offer or ask for paid work of any kind.",
+                {"work", "money"}
             ),
         ])
 
-- 
cgit v1.2.3


From a75ba77bc8b83af97decde6c5ac4317bb3b5253d Mon Sep 17 00:00:00 2001
From: Amrou Bellalouna <Amrou.bellalouna@expensya.com>
Date: Sun, 18 Sep 2022 18:38:02 +0100
Subject: add docstrings explaining the values that the Rules view returns

---
 pydis_site/apps/api/views.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'pydis_site/apps/api')

diff --git a/pydis_site/apps/api/views.py b/pydis_site/apps/api/views.py
index f96d6a8d..66f4b18c 100644
--- a/pydis_site/apps/api/views.py
+++ b/pydis_site/apps/api/views.py
@@ -100,6 +100,7 @@ class RulesView(APIView):
 
     # `format` here is the result format, we have a link format here instead.
     def get(self, request, format=None):  # noqa: D102,ANN001,ANN201
+        """Returns a list of our community rules coupled with their keywords."""
         link_format = request.query_params.get('link_format', 'md')
         if link_format not in ('html', 'md'):
             raise ParseError(
-- 
cgit v1.2.3


From 672ba65b02fb111235fd3b928d5c84ee8b59cc54 Mon Sep 17 00:00:00 2001
From: Amrou Bellalouna <Amrou.bellalouna@expensya.com>
Date: Sun, 18 Sep 2022 18:43:05 +0100
Subject: add suggested keywords

---
 pydis_site/apps/api/views.py | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

(limited to 'pydis_site/apps/api')

diff --git a/pydis_site/apps/api/views.py b/pydis_site/apps/api/views.py
index 66f4b18c..836f11ce 100644
--- a/pydis_site/apps/api/views.py
+++ b/pydis_site/apps/api/views.py
@@ -126,43 +126,43 @@ class RulesView(APIView):
         return Response([
             (
                 f"Follow the {pydis_coc}.",
-                {"coc", "conduct", "code"}
+                ["coc", "conduct", "code"]
             ),
             (
                 f"Follow the {discord_community_guidelines} and {discord_tos}.",
-                {"guidelines", "discord_tos"}
+                ["discord", "guidelines", "discord_tos"]
             ),
             (
                 "Respect staff members and listen to their instructions.",
-                {"staff", "instructions"}
+                ["respect", "staff", "instructions"]
             ),
             (
                 "Use English to the best of your ability. "
                 "Be polite if someone speaks English imperfectly.",
-                {"english", "language"}
+                ["english", "language"]
             ),
             (
                 "Do not provide or request help on projects that may break laws, "
                 "breach terms of services, or are malicious or inappropriate.",
-                {"infraction", "tos", "breach", "malicious", "inappropriate"}
+                ["infraction", "tos", "breach", "malicious", "inappropriate"]
             ),
             (
                 "Do not post unapproved advertising.",
-                {"ads", "advertising"}
+                ["ad", "ads", "advert", "advertising"]
             ),
             (
                 "Keep discussions relevant to the channel topic. "
                 "Each channel's description tells you the topic.",
-                {"off-topic", "topic", "relevance"}
+                ["off-topic", "topic", "relevance"]
             ),
             (
                 "Do not help with ongoing exams. When helping with homework, "
                 "help people learn how to do the assignment without doing it for them.",
-                {"exams", "assignment", "assignments", "homework"}
+                ["exam", "exams", "assignment", "assignments", "homework"]
             ),
             (
                 "Do not offer or ask for paid work of any kind.",
-                {"work", "money"}
+                ["paid", "work", "money"]
             ),
         ])
 
-- 
cgit v1.2.3


From f07f03abd53789062045afb027ef2d5ecfd63f11 Mon Sep 17 00:00:00 2001
From: Amrou Bellalouna <Amrou.bellalouna@expensya.com>
Date: Sun, 18 Sep 2022 18:44:33 +0100
Subject: make docstring more explicit about the returned content

---
 pydis_site/apps/api/views.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'pydis_site/apps/api')

diff --git a/pydis_site/apps/api/views.py b/pydis_site/apps/api/views.py
index 836f11ce..f76a78ff 100644
--- a/pydis_site/apps/api/views.py
+++ b/pydis_site/apps/api/views.py
@@ -100,7 +100,12 @@ class RulesView(APIView):
 
     # `format` here is the result format, we have a link format here instead.
     def get(self, request, format=None):  # noqa: D102,ANN001,ANN201
-        """Returns a list of our community rules coupled with their keywords."""
+        """
+        Returns a list of our community rules coupled with their keywords.
+
+        Each item in the returned list is a tuple with the rule as first item
+        and a list of keywords that match that rules as second item.
+        """
         link_format = request.query_params.get('link_format', 'md')
         if link_format not in ('html', 'md'):
             raise ParseError(
-- 
cgit v1.2.3


From 13ae666f0281c7dcfbbe79fdf431f28cd822ec19 Mon Sep 17 00:00:00 2001
From: Amrou Bellalouna <Amrou.bellalouna@expensya.com>
Date: Sun, 18 Sep 2022 18:55:18 +0100
Subject: update the RulesView class' docstrings

---
 pydis_site/apps/api/views.py | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

(limited to 'pydis_site/apps/api')

diff --git a/pydis_site/apps/api/views.py b/pydis_site/apps/api/views.py
index f76a78ff..3cb7e8bd 100644
--- a/pydis_site/apps/api/views.py
+++ b/pydis_site/apps/api/views.py
@@ -37,12 +37,15 @@ class RulesView(APIView):
 
     ## Routes
     ### GET /rules
-    Returns a JSON array containing the server's rules:
+    Returns a JSON array containing the server's rules
+    coupled with a list of keywords that will be used
+    when searching for particular rules upon using the
+    bot's `!rule` command
 
     >>> [
-    ...     "Eat candy.",
-    ...     "Wake up at 4 AM.",
-    ...     "Take your medicine."
+    ...     ("Eat candy.", ["candy", "sweet"]),
+    ...     ("Wake up at 4 AM.", ["wake_up", "early", "early_bird"]),
+    ...     ("Take your medicine.", ["medicine", "health"])
     ... ]
 
     Since some of the the rules require links, this view
-- 
cgit v1.2.3


From 49909a3165344b0fdbd81300cc752327e08f0ff5 Mon Sep 17 00:00:00 2001
From: Amrou Bellalouna <Amrou.bellalouna@expensya.com>
Date: Sun, 18 Sep 2022 18:57:16 +0100
Subject: replace sweet with "sweets" to refer more to candy

---
 pydis_site/apps/api/views.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pydis_site/apps/api')

diff --git a/pydis_site/apps/api/views.py b/pydis_site/apps/api/views.py
index 3cb7e8bd..2c5343de 100644
--- a/pydis_site/apps/api/views.py
+++ b/pydis_site/apps/api/views.py
@@ -43,7 +43,7 @@ class RulesView(APIView):
     bot's `!rule` command
 
     >>> [
-    ...     ("Eat candy.", ["candy", "sweet"]),
+    ...     ("Eat candy.", ["candy", "sweets"]),
     ...     ("Wake up at 4 AM.", ["wake_up", "early", "early_bird"]),
     ...     ("Take your medicine.", ["medicine", "health"])
     ... ]
-- 
cgit v1.2.3


From e6db60717efe799e0900ad6cf60f4962f1aef7a1 Mon Sep 17 00:00:00 2001
From: Amrou Bellalouna <Amrou.bellalouna@expensya.com>
Date: Sun, 18 Sep 2022 19:11:36 +0100
Subject: restrict the RulesView docstrings to just what it does

---
 pydis_site/apps/api/views.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'pydis_site/apps/api')

diff --git a/pydis_site/apps/api/views.py b/pydis_site/apps/api/views.py
index 2c5343de..9e5ad73c 100644
--- a/pydis_site/apps/api/views.py
+++ b/pydis_site/apps/api/views.py
@@ -38,9 +38,8 @@ class RulesView(APIView):
     ## Routes
     ### GET /rules
     Returns a JSON array containing the server's rules
-    coupled with a list of keywords that will be used
-    when searching for particular rules upon using the
-    bot's `!rule` command
+    and keywords relating to each rule.
+    Example response:
 
     >>> [
     ...     ("Eat candy.", ["candy", "sweets"]),
-- 
cgit v1.2.3


From 7fd81a80049763f1dc71815da27d65ce4344a191 Mon Sep 17 00:00:00 2001
From: Amrou Bellalouna <Amrou.bellalouna@expensya.com>
Date: Sun, 18 Sep 2022 22:18:50 +0100
Subject: replace parenthesis with square brackets since tuples are serialized
 are lists

---
 pydis_site/apps/api/views.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'pydis_site/apps/api')

diff --git a/pydis_site/apps/api/views.py b/pydis_site/apps/api/views.py
index 9e5ad73c..34167a38 100644
--- a/pydis_site/apps/api/views.py
+++ b/pydis_site/apps/api/views.py
@@ -42,9 +42,9 @@ class RulesView(APIView):
     Example response:
 
     >>> [
-    ...     ("Eat candy.", ["candy", "sweets"]),
-    ...     ("Wake up at 4 AM.", ["wake_up", "early", "early_bird"]),
-    ...     ("Take your medicine.", ["medicine", "health"])
+    ...     ["Eat candy.", ["candy", "sweets"]],
+    ...     ["Wake up at 4 AM.", ["wake_up", "early", "early_bird"]],
+    ...     ["Take your medicine.", ["medicine", "health"]]
     ... ]
 
     Since some of the the rules require links, this view
-- 
cgit v1.2.3