codegrade 17.0.0__tar.gz → 17.0.1__tar.gz

{codegrade-17.0.0 → codegrade-17.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegrade
-Version: 17.0.0
+Version: 17.0.1
 Summary: A client library for accessing CodeGrade
 Project-URL: Documentation, https://python.api.codegrade.com
 License-Expression: AGPL-3.0-only OR BSD-3-Clause-Clear

{codegrade-17.0.0 → codegrade-17.0.1}/docs/conf.py

@@ -39,7 +39,7 @@ author = "CodeGrade Team"
 # built documents.
 #
 # The short X.Y version.
-version = "17.0.0"
+version = "17.0.1"
 # The full version, including alpha/beta/rc tags.
 release = version
 
@@ -103,7 +103,7 @@ html_js_files = ["toggle.js"]
 
 html_favicon = "_static/favicon/favicon.ico"
 html_logo = "_static/images/logo.svg"
-html_title = "CodeGrade 17.0.0"
+html_title = "CodeGrade 17.0.1"
 
 # -- Extension configuration -------------------------------------------------
 

{codegrade-17.0.0 → codegrade-17.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codegrade"
-version = "17.0.0"
+version = "17.0.1"
 description = "A client library for accessing CodeGrade"
 authors = []
 requires-python = ">=3.8.0,<4.0"

{codegrade-17.0.0 → codegrade-17.0.1}/src/cg_dt_utils/__init__.py

@@ -110,6 +110,8 @@ if t.TYPE_CHECKING:  # pragma: no cover
 
         def strftime(self, format: str) -> str: ...
 
+        def date(self) -> datetime.date: ...
+
 else:
     # Warning, this class is not actually used during runtime, and is only
     # present for type checking (to make sure we only use dates with a timezone

{codegrade-17.0.0 → codegrade-17.0.1}/src/cg_maybe/utils.py

@@ -39,6 +39,14 @@ def from_nullable(val: t.Optional[_T]) -> Maybe[_T]:
     return Just(val)
 
 
+@t.overload
+def maybe_from_nullable(val: t.Union[Maybe[_T]]) -> Maybe[_T]: ...
+
+
+@t.overload
+def maybe_from_nullable(val: t.Union[None, _T]) -> Maybe[_T]: ...
+
+
 def maybe_from_nullable(val: t.Union[None, _T, Maybe[_T]]) -> Maybe[_T]:
     """Convert a nullalbe to a maybe if it isn't already a maybe.
 

{codegrade-17.0.0 → codegrade-17.0.1}/src/codegrade/__init__.py

@@ -17,7 +17,7 @@ except ImportError:
     )
 
 __all__ = ("login", "AuthenticatedClient", "Client", "login_from_cli")
-__version__ = "17.0.0"
+__version__ = "17.0.1"
 
 _P = _ParamSpec("_P")
 _T = _t.TypeVar("_T")

{codegrade-17.0.0 → codegrade-17.0.1}/src/codegrade/_api/about.py

@@ -43,13 +43,13 @@ class AboutService(t.Generic[_ClientT]):
         """
 
         url = "/api/v1/about"
-        params: t.Dict[str, t.Any] = {}
-        maybe_from_nullable(t.cast(t.Any, health)).if_just(
-            lambda val: params.__setitem__("health", val)
-        )
-        maybe_from_nullable(t.cast(t.Any, tenant_id)).if_just(
-            lambda val: params.__setitem__("tenant_id", val)
-        )
+        params: t.Dict[str, str | int | bool] = {}
+        health_as_maybe = maybe_from_nullable(health)
+        if health_as_maybe.is_just:
+            params["health"] = health_as_maybe.value
+        tenant_id_as_maybe = maybe_from_nullable(tenant_id)
+        if tenant_id_as_maybe.is_just:
+            params["tenant_id"] = tenant_id_as_maybe.value
 
         with self.__client as client:
             resp = client.http.get(url=url, params=params)

{codegrade-17.0.0 → codegrade-17.0.1}/src/codegrade/_api/assignment.py

@@ -82,6 +82,7 @@ class AssignmentService(t.Generic[_ClientT]):
         """Return the rubric corresponding to the given `assignment_id`.
 
         :param assignment_id: The id of the assignment.
+        :param page_size: The size of a single page, maximum is 100.
 
         :returns: A list of `RubricRow` items.
         """
@@ -89,21 +90,20 @@ class AssignmentService(t.Generic[_ClientT]):
         url = "/api/v1/assignments/{assignmentId}/rubrics/".format(
             assignmentId=assignment_id
         )
-        headers: t.Dict[str, str] = {
-            "page-size": str(page_size),
+        params: t.Dict[str, str | int | bool] = {
+            "page-size": page_size,
         }
-        params = None
 
         if t.TYPE_CHECKING:
             import httpx
 
         def do_request(next_token: str | None) -> httpx.Response:
             if next_token is None:
-                headers.pop("next-token", "")
+                params.pop("next-token", "")
             else:
-                headers["next-token"] = next_token
+                params["next-token"] = next_token
             with self.__client as client:
-                resp = client.http.get(url=url, headers=headers, params=params)
+                resp = client.http.get(url=url, params=params)
             utils.log_warnings(resp)
 
             return resp
@@ -733,6 +733,7 @@ class AssignmentService(t.Generic[_ClientT]):
         """Get the grades for all submissions in this assignment.
 
         :param assignment_id: The id of assignment to export the gradebook for.
+        :param page_size: The size of a single page, maximum is 200.
 
         :returns: The rows of the gradebook.
         """
@@ -740,21 +741,20 @@ class AssignmentService(t.Generic[_ClientT]):
         url = "/api/v1/assignments/{assignmentId}/grades/".format(
             assignmentId=assignment_id
         )
-        headers: t.Dict[str, str] = {
-            "page-size": str(page_size),
+        params: t.Dict[str, str | int | bool] = {
+            "page-size": page_size,
         }
-        params = None
 
         if t.TYPE_CHECKING:
             import httpx
 
         def do_request(next_token: str | None) -> httpx.Response:
             if next_token is None:
-                headers.pop("next-token", "")
+                params.pop("next-token", "")
             else:
-                headers["next-token"] = next_token
+                params["next-token"] = next_token
             with self.__client as client:
-                resp = client.http.get(url=url, headers=headers, params=params)
+                resp = client.http.get(url=url, params=params)
             utils.log_warnings(resp)
 
             return resp
@@ -794,6 +794,7 @@ class AssignmentService(t.Generic[_ClientT]):
         """Gets a list of all users that can grade in the given assignment.
 
         :param assignment_id: The id of the assignment
+        :param page_size: The size of a single page, maximum is 50.
 
         :returns: A response containing the JSON serialized graders.
         """
@@ -801,21 +802,20 @@ class AssignmentService(t.Generic[_ClientT]):
         url = "/api/v1/assignments/{assignmentId}/graders/".format(
             assignmentId=assignment_id
         )
-        headers: t.Dict[str, str] = {
-            "page-size": str(page_size),
+        params: t.Dict[str, str | int | bool] = {
+            "page-size": page_size,
         }
-        params = None
 
         if t.TYPE_CHECKING:
             import httpx
 
         def do_request(next_token: str | None) -> httpx.Response:
             if next_token is None:
-                headers.pop("next-token", "")
+                params.pop("next-token", "")
             else:
-                headers["next-token"] = next_token
+                params["next-token"] = next_token
             with self.__client as client:
-                resp = client.http.get(url=url, headers=headers, params=params)
+                resp = client.http.get(url=url, params=params)
             utils.log_warnings(resp)
 
             return resp
@@ -859,6 +859,7 @@ class AssignmentService(t.Generic[_ClientT]):
 
         :param assignment_id: The id of the assignment
         :param user_id: The user of which you want to get the submissions.
+        :param page_size: The size of a single page, maximum is 50.
 
         :returns: A response containing the JSON serialized submissions.
         """
@@ -866,21 +867,20 @@ class AssignmentService(t.Generic[_ClientT]):
         url = "/api/v1/assignments/{assignmentId}/users/{userId}/submissions/".format(
             assignmentId=assignment_id, userId=user_id
         )
-        headers: t.Dict[str, str] = {
-            "page-size": str(page_size),
+        params: t.Dict[str, str | int | bool] = {
+            "page-size": page_size,
         }
-        params = None
 
         if t.TYPE_CHECKING:
             import httpx
 
         def do_request(next_token: str | None) -> httpx.Response:
             if next_token is None:
-                headers.pop("next-token", "")
+                params.pop("next-token", "")
             else:
-                headers["next-token"] = next_token
+                params["next-token"] = next_token
             with self.__client as client:
-                resp = client.http.get(url=url, headers=headers, params=params)
+                resp = client.http.get(url=url, params=params)
             utils.log_warnings(resp)
 
             return resp
@@ -921,6 +921,7 @@ class AssignmentService(t.Generic[_ClientT]):
         :param q: Filter the submissions returned based on this string.
         :param test_student: If give only return submissions that either are or
             are not of the test student.
+        :param page_size: The size of a single page, maximum is 100.
 
         :returns: A response containing the JSON serialized submissions.
         """
@@ -928,26 +929,24 @@ class AssignmentService(t.Generic[_ClientT]):
         url = "/api/v1/assignments/{assignmentId}/submissions/".format(
             assignmentId=assignment_id
         )
-        headers: t.Dict[str, str] = {
-            "page-size": str(page_size),
-        }
-        params: t.Dict[str, t.Any] = {
-            "q": utils.to_dict(q),
+        params: t.Dict[str, str | int | bool] = {
+            "q": q,
+            "page-size": page_size,
         }
-        maybe_from_nullable(t.cast(t.Any, test_student)).if_just(
-            lambda val: params.__setitem__("test_student", val)
-        )
+        test_student_as_maybe = maybe_from_nullable(test_student)
+        if test_student_as_maybe.is_just:
+            params["test_student"] = test_student_as_maybe.value
 
         if t.TYPE_CHECKING:
             import httpx
 
         def do_request(next_token: str | None) -> httpx.Response:
             if next_token is None:
-                headers.pop("next-token", "")
+                params.pop("next-token", "")
             else:
-                headers["next-token"] = next_token
+                params["next-token"] = next_token
             with self.__client as client:
-                resp = client.http.get(url=url, headers=headers, params=params)
+                resp = client.http.get(url=url, params=params)
             utils.log_warnings(resp)
 
             return resp
@@ -989,6 +988,7 @@ class AssignmentService(t.Generic[_ClientT]):
             get the data.
         :param data_source_name: The name of the data source of which you wan
             to get the data.
+        :param page_size: The size of a single page, maximum is 250.
 
         :returns: A paginated list of the data.
         """
@@ -996,21 +996,20 @@ class AssignmentService(t.Generic[_ClientT]):
         url = "/api/v1/assignments/{assignmentId}/analytics/{dataSourceName}/data/".format(
             assignmentId=assignment_id, dataSourceName=data_source_name
         )
-        headers: t.Dict[str, str] = {
-            "page-size": str(page_size),
+        params: t.Dict[str, str | int | bool] = {
+            "page-size": page_size,
         }
-        params = None
 
         if t.TYPE_CHECKING:
             import httpx
 
         def do_request(next_token: str | None) -> httpx.Response:
             if next_token is None:
-                headers.pop("next-token", "")
+                params.pop("next-token", "")
             else:
-                headers["next-token"] = next_token
+                params["next-token"] = next_token
             with self.__client as client:
-                resp = client.http.get(url=url, headers=headers, params=params)
+                resp = client.http.get(url=url, params=params)
             utils.log_warnings(resp)
 
             return resp
@@ -1235,13 +1234,13 @@ class AssignmentService(t.Generic[_ClientT]):
         url = "/api/v1/assignments/{assignmentId}/webhook_settings".format(
             assignmentId=assignment_id
         )
-        params: t.Dict[str, t.Any] = {
-            "webhook_type": utils.to_dict(webhook_type),
-            "is_test_submission": utils.to_dict(is_test_submission),
+        params: t.Dict[str, str | int | bool] = {
+            "webhook_type": webhook_type,
+            "is_test_submission": is_test_submission,
         }
-        maybe_from_nullable(t.cast(t.Any, author_id)).if_just(
-            lambda val: params.__setitem__("author_id", val)
-        )
+        author_id_as_maybe = maybe_from_nullable(author_id)
+        if author_id_as_maybe.is_just:
+            params["author_id"] = author_id_as_maybe.value
 
         with self.__client as client:
             resp = client.http.post(url=url, params=params)
@@ -1328,6 +1327,7 @@ class AssignmentService(t.Generic[_ClientT]):
         :param user_id: The ID of the user whose peer feedback duties are being
             requested. For group assignments, providing an individual member's
             ID will return the subjects assigned to their entire group.
+        :param page_size: The size of a single page, maximum is 50.
 
         :returns: A paginated list of peer feedback subjects. Returns an empty
                   list if the assignment's feedback period is not active or if
@@ -1337,21 +1337,20 @@ class AssignmentService(t.Generic[_ClientT]):
         url = "/api/v1/assignments/{assignmentId}/users/{userId}/peer_feedback_subjects/".format(
             assignmentId=assignment_id, userId=user_id
         )
-        headers: t.Dict[str, str] = {
-            "page-size": str(page_size),
+        params: t.Dict[str, str | int | bool] = {
+            "page-size": page_size,
         }
-        params = None
 
         if t.TYPE_CHECKING:
             import httpx
 
         def do_request(next_token: str | None) -> httpx.Response:
             if next_token is None:
-                headers.pop("next-token", "")
+                params.pop("next-token", "")
             else:
-                headers["next-token"] = next_token
+                params["next-token"] = next_token
             with self.__client as client:
-                resp = client.http.get(url=url, headers=headers, params=params)
+                resp = client.http.get(url=url, params=params)
             utils.log_warnings(resp)
 
             return resp
@@ -1397,6 +1396,7 @@ class AssignmentService(t.Generic[_ClientT]):
 
         :param assignment_id: The id of the assignment
         :param q: Search the runs based on this value.
+        :param page_size: The size of a single page, maximum is 50.
 
         :returns: A response containing the JSON serialized list of plagiarism
                   runs.
@@ -1405,11 +1405,9 @@ class AssignmentService(t.Generic[_ClientT]):
         url = "/api/v1/assignments/{assignmentId}/plagiarism/".format(
             assignmentId=assignment_id
         )
-        headers: t.Dict[str, str] = {
-            "page-size": str(page_size),
-        }
-        params: t.Dict[str, t.Any] = {
-            "q": utils.to_dict(q),
+        params: t.Dict[str, str | int | bool] = {
+            "q": q,
+            "page-size": page_size,
         }
 
         if t.TYPE_CHECKING:
@@ -1417,11 +1415,11 @@ class AssignmentService(t.Generic[_ClientT]):
 
         def do_request(next_token: str | None) -> httpx.Response:
             if next_token is None:
-                headers.pop("next-token", "")
+                params.pop("next-token", "")
             else:
-                headers["next-token"] = next_token
+                params["next-token"] = next_token
             with self.__client as client:
-                resp = client.http.get(url=url, headers=headers, params=params)
+                resp = client.http.get(url=url, params=params)
             utils.log_warnings(resp)
 
             return resp
@@ -1464,6 +1462,7 @@ class AssignmentService(t.Generic[_ClientT]):
 
         :param assignment_id: The ID of the assignment to scope the search to.
         :param user_id: The ID of the user whose replies are being counted.
+        :param page_size: The size of a single page, maximum is 50.
 
         :returns: A paginated response. The data payload is a list of objects,
                   each mapping a submission's ID to the total count of replies
@@ -1473,21 +1472,20 @@ class AssignmentService(t.Generic[_ClientT]):
         url = "/api/v1/assignments/{assignmentId}/users/{userId}/replies/counts-by-submission/".format(
             assignmentId=assignment_id, userId=user_id
         )
-        headers: t.Dict[str, str] = {
-            "page-size": str(page_size),
+        params: t.Dict[str, str | int | bool] = {
+            "page-size": page_size,
         }
-        params = None
 
         if t.TYPE_CHECKING:
             import httpx
 
         def do_request(next_token: str | None) -> httpx.Response:
             if next_token is None:
-                headers.pop("next-token", "")
+                params.pop("next-token", "")
             else:
-                headers["next-token"] = next_token
+                params["next-token"] = next_token
             with self.__client as client:
-                resp = client.http.get(url=url, headers=headers, params=params)
+                resp = client.http.get(url=url, params=params)
             utils.log_warnings(resp)
 
             return resp
@@ -1823,13 +1821,13 @@ class AssignmentService(t.Generic[_ClientT]):
         url = "/api/v1/assignments/{assignmentId}/submission".format(
             assignmentId=assignment_id
         )
-        params: t.Dict[str, t.Any] = {
-            "is_test_submission": utils.to_dict(is_test_submission),
-            "ignored_files": utils.to_dict(ignored_files),
+        params: t.Dict[str, str | int | bool] = {
+            "is_test_submission": is_test_submission,
+            "ignored_files": ignored_files,
         }
-        maybe_from_nullable(t.cast(t.Any, author_id)).if_just(
-            lambda val: params.__setitem__("author_id", val)
-        )
+        author_id_as_maybe = maybe_from_nullable(author_id)
+        if author_id_as_maybe.is_just:
+            params["author_id"] = author_id_as_maybe.value
 
         data, files = utils.to_multipart(utils.to_dict(multipart_data))
 

{codegrade-17.0.0 → codegrade-17.0.1}/src/codegrade/_api/auto_test.py

@@ -823,10 +823,10 @@ class AutoTestService(t.Generic[_ClientT]):
         """
 
         url = "/api/v1/auto_test_results/"
-        params: t.Dict[str, t.Any] = {
-            "offset": utils.to_dict(offset),
-            "limit": utils.to_dict(limit),
-            "state": utils.to_dict(state),
+        params: t.Dict[str, str | int | bool] = {
+            "offset": offset,
+            "limit": limit,
+            "state": state,
         }
 
         with self.__client as client:

{codegrade-17.0.0 → codegrade-17.0.1}/src/codegrade/_api/comment.py

@@ -10,6 +10,7 @@ import typing as t
 
 import cg_request_args as rqa
 from cg_maybe import Maybe, Nothing
+from cg_maybe.utils import maybe_from_nullable
 
 from .. import paginated, parsers, utils
 
@@ -256,6 +257,7 @@ class CommentService(t.Generic[_ClientT]):
         :param comment_base_id: The base of the given reply.
         :param reply_id: The id of the reply for which you want to get the
             edits.
+        :param page_size: The size of a single page, maximum is 50.
 
         :returns: A list of edits, sorted from newest to oldest.
         """
@@ -265,21 +267,20 @@ class CommentService(t.Generic[_ClientT]):
                 commentBaseId=comment_base_id, replyId=reply_id
             )
         )
-        headers: t.Dict[str, str] = {
-            "page-size": str(page_size),
+        params: t.Dict[str, str | int | bool] = {
+            "page-size": page_size,
         }
-        params = None
 
         if t.TYPE_CHECKING:
             import httpx
 
         def do_request(next_token: str | None) -> httpx.Response:
             if next_token is None:
-                headers.pop("next-token", "")
+                params.pop("next-token", "")
             else:
-                headers["next-token"] = next_token
+                params["next-token"] = next_token
             with self.__client as client:
-                resp = client.http.get(url=url, headers=headers, params=params)
+                resp = client.http.get(url=url, params=params)
             utils.log_warnings(resp)
 
             return resp