codegrade 17.0.67__tar.gz → 17.0.68__tar.gz

{codegrade-17.0.67 → codegrade-17.0.68}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegrade
-Version: 17.0.67
+Version: 17.0.68
 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.67 → codegrade-17.0.68}/docs/conf.py

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

codegrade-17.0.68/docs/models/ArchiveQuarantinedRegistrationData.rst

@@ -0,0 +1,9 @@
+ArchiveQuarantinedRegistrationData
+==================================
+
+.. currentmodule:: codegrade.models.archive_quarantined_registration_data
+
+.. autoclass:: ArchiveQuarantinedRegistrationData
+   :members: email
+   :inherited-members:
+   :exclude-members: raw_data, data_parser, to_dict, from_dict, __init__, __new__

{codegrade-17.0.67 → codegrade-17.0.68}/docs/models/QuarantinedRegistration.rst

@@ -4,6 +4,6 @@ QuarantinedRegistration
 .. currentmodule:: codegrade.models.quarantined_registration
 
 .. autoclass:: QuarantinedRegistration
-   :members: id, email, username, name, created_at
+   :members: id, email, username, name, created_at, archived_at
    :inherited-members:
    :exclude-members: raw_data, data_parser, to_dict, from_dict, __init__, __new__

{codegrade-17.0.67 → codegrade-17.0.68}/docs/services/quarantined_registration.rst

@@ -5,7 +5,7 @@ QuarantinedRegistrationService
 .. currentmodule:: codegrade._api.quarantined_registration
 
 .. autoclass:: QuarantinedRegistrationService
-   :members: accept, deny, get_all
+   :members: accept, archive, deny, get_all_archived, get_all, unarchive
 
 	 .. rubric:: Methods
 
@@ -13,5 +13,8 @@ QuarantinedRegistrationService
 	    :nosignatures:
 
 			~QuarantinedRegistrationService.accept
+			~QuarantinedRegistrationService.archive
 			~QuarantinedRegistrationService.deny
+			~QuarantinedRegistrationService.get_all_archived
 			~QuarantinedRegistrationService.get_all
+			~QuarantinedRegistrationService.unarchive

{codegrade-17.0.67 → codegrade-17.0.68}/pyproject.toml

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

{codegrade-17.0.67 → codegrade-17.0.68}/src/codegrade/__init__.py

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

codegrade-17.0.68/src/codegrade/_api/quarantined_registration.py

@@ -0,0 +1,314 @@
+"""The endpoints for quarantined_registration objects.
+
+SPDX-License-Identifier: AGPL-3.0-only OR BSD-3-Clause-Clear
+"""
+
+from __future__ import annotations
+
+import os
+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
+
+if t.TYPE_CHECKING or os.getenv("CG_EAGERIMPORT", False):
+    from .. import client
+    from ..models.accept_quarantined_registration_data import (
+        AcceptQuarantinedRegistrationData,
+    )
+    from ..models.archive_quarantined_registration_data import (
+        ArchiveQuarantinedRegistrationData,
+    )
+    from ..models.deny_quarantined_registration_data import (
+        DenyQuarantinedRegistrationData,
+    )
+    from ..models.quarantined_registration import QuarantinedRegistration
+
+
+_ClientT = t.TypeVar("_ClientT", bound="client._BaseClient")
+
+
+class QuarantinedRegistrationService(t.Generic[_ClientT]):
+    __slots__ = ("__client",)
+
+    def __init__(self, client: _ClientT) -> None:
+        self.__client = client
+
+    def accept(
+        self: QuarantinedRegistrationService[client.AuthenticatedClient],
+        json_body: AcceptQuarantinedRegistrationData,
+        *,
+        quarantined_registration_id: str,
+    ) -> t.Sequence[QuarantinedRegistration]:
+        """Accept quarantined registrations.
+
+        :param json_body: The body of the request. See
+            :class:`.AcceptQuarantinedRegistrationData` for information about
+            the possible fields. You can provide this data as a
+            :class:`.AcceptQuarantinedRegistrationData` or as a dictionary.
+        :param quarantined_registration_id: Registration id to accept.
+
+        :returns: The same-email duplicate registrations that were archived as
+                  a side effect. The accepted registration itself is deleted;
+                  the client knows its id and removes it from the active board
+                  along with these.
+        """
+
+        url = "/api/v1/quarantined_registrations/{quarantinedRegistrationId}/accept".format(
+            quarantinedRegistrationId=quarantined_registration_id
+        )
+        params = None
+
+        with self.__client as client:
+            resp = client.http.post(
+                url=url, json=utils.to_dict(json_body), params=params
+            )
+        utils.log_warnings(resp)
+
+        if utils.response_code_matches(resp.status_code, 200):
+            from ..models.quarantined_registration import (
+                QuarantinedRegistration,
+            )
+
+            return parsers.JsonResponseParser(
+                rqa.List(parsers.ParserFor.make(QuarantinedRegistration))
+            ).try_parse(resp)
+
+        from ..models.any_error import AnyErrorParser
+
+        raise utils.get_error(
+            resp, (((400, 409, 401, 403, 404, 429, 500), AnyErrorParser),)
+        )
+
+    def archive(
+        self: QuarantinedRegistrationService[client.AuthenticatedClient],
+        json_body: ArchiveQuarantinedRegistrationData,
+    ) -> t.Sequence[QuarantinedRegistration]:
+        """Archive all active quarantined registrations for an email address.
+
+        This clears duplicate signups from the board without notifying the
+        user. Every active registration for the email is archived, not just a
+        single row, because duplicates may span multiple pages of the list.
+
+        :param json_body: The body of the request. See
+            :class:`.ArchiveQuarantinedRegistrationData` for information about
+            the possible fields. You can provide this data as a
+            :class:`.ArchiveQuarantinedRegistrationData` or as a dictionary.
+
+        :returns: The registrations that were archived, so the client can drop
+                  exactly those rows from the active board.
+        """
+
+        url = "/api/v1/quarantined_registrations/archive"
+        params = None
+
+        with self.__client as client:
+            resp = client.http.post(
+                url=url, json=utils.to_dict(json_body), params=params
+            )
+        utils.log_warnings(resp)
+
+        if utils.response_code_matches(resp.status_code, 200):
+            from ..models.quarantined_registration import (
+                QuarantinedRegistration,
+            )
+
+            return parsers.JsonResponseParser(
+                rqa.List(parsers.ParserFor.make(QuarantinedRegistration))
+            ).try_parse(resp)
+
+        from ..models.any_error import AnyErrorParser
+
+        raise utils.get_error(
+            resp, (((400, 409, 401, 403, 404, 429, 500), AnyErrorParser),)
+        )
+
+    def deny(
+        self: QuarantinedRegistrationService[client.AuthenticatedClient],
+        json_body: DenyQuarantinedRegistrationData,
+        *,
+        quarantined_registration_id: str,
+    ) -> t.Sequence[QuarantinedRegistration]:
+        """Deny quarantined registrations.
+
+        :param json_body: The body of the request. See
+            :class:`.DenyQuarantinedRegistrationData` for information about the
+            possible fields. You can provide this data as a
+            :class:`.DenyQuarantinedRegistrationData` or as a dictionary.
+        :param quarantined_registration_id: Registration id to accept.
+
+        :returns: The same-email duplicate registrations that were archived as
+                  a side effect. The denied registration itself is deleted; the
+                  client knows its id and removes it from the active board
+                  along with these.
+        """
+
+        url = "/api/v1/quarantined_registrations/{quarantinedRegistrationId}/deny".format(
+            quarantinedRegistrationId=quarantined_registration_id
+        )
+        params = None
+
+        with self.__client as client:
+            resp = client.http.post(
+                url=url, json=utils.to_dict(json_body), params=params
+            )
+        utils.log_warnings(resp)
+
+        if utils.response_code_matches(resp.status_code, 200):
+            from ..models.quarantined_registration import (
+                QuarantinedRegistration,
+            )
+
+            return parsers.JsonResponseParser(
+                rqa.List(parsers.ParserFor.make(QuarantinedRegistration))
+            ).try_parse(resp)
+
+        from ..models.any_error import AnyErrorParser
+
+        raise utils.get_error(
+            resp, (((400, 409, 401, 403, 404, 429, 500), AnyErrorParser),)
+        )
+
+    def get_all_archived(
+        self: QuarantinedRegistrationService[client.AuthenticatedClient],
+        *,
+        page_size: int = 25,
+    ) -> paginated.Response[QuarantinedRegistration]:
+        """List the archived quarantined registrations.
+
+        Separate from the active list (:func:`.get_quarantined_registrations`)
+        because it sorts by `archived_at` rather than `created_at`, so support
+        sees what they most recently archived first.
+
+        :param page_size: The size of a single page, maximum is 100.
+
+        :returns: Paginated archived registrations, most recently archived
+                  first.
+        """
+
+        url = "/api/v1/quarantined_registrations/archived/"
+        params: t.Dict[str, str | int | bool] = {
+            "page-size": page_size,
+        }
+
+        if t.TYPE_CHECKING:
+            import httpx
+
+        def do_request(next_token: str | None) -> httpx.Response:
+            if next_token is None:
+                params.pop("next-token", "")
+            else:
+                params["next-token"] = next_token
+            with self.__client as client:
+                resp = client.http.get(url=url, params=params)
+            utils.log_warnings(resp)
+
+            return resp
+
+        def parse_response(
+            resp: httpx.Response,
+        ) -> t.Sequence[QuarantinedRegistration]:
+            if utils.response_code_matches(resp.status_code, 200):
+                from ..models.quarantined_registration import (
+                    QuarantinedRegistration,
+                )
+
+                return parsers.JsonResponseParser(
+                    rqa.List(parsers.ParserFor.make(QuarantinedRegistration))
+                ).try_parse(resp)
+
+            from ..models.any_error import AnyErrorParser
+
+            raise utils.get_error(
+                resp, (((400, 409, 401, 403, 404, 429, 500), AnyErrorParser),)
+            )
+
+        return paginated.Response(do_request, parse_response)
+
+    def get_all(
+        self: QuarantinedRegistrationService[client.AuthenticatedClient],
+        *,
+        page_size: int = 25,
+    ) -> paginated.Response[QuarantinedRegistration]:
+        """List the active quarantined registrations awaiting review.
+
+        Archived registrations are listed separately by `archived_at` instead
+        of `created_at`. Keeping them apart gives each list a fixed
+        pagination-token shape rather than one that changes with a query flag.
+
+        :param page_size: The size of a single page, maximum is 100.
+
+        :returns: Paginated active registrations, newest signup first.
+        """
+
+        url = "/api/v1/quarantined_registrations/"
+        params: t.Dict[str, str | int | bool] = {
+            "page-size": page_size,
+        }
+
+        if t.TYPE_CHECKING:
+            import httpx
+
+        def do_request(next_token: str | None) -> httpx.Response:
+            if next_token is None:
+                params.pop("next-token", "")
+            else:
+                params["next-token"] = next_token
+            with self.__client as client:
+                resp = client.http.get(url=url, params=params)
+            utils.log_warnings(resp)
+
+            return resp
+
+        def parse_response(
+            resp: httpx.Response,
+        ) -> t.Sequence[QuarantinedRegistration]:
+            if utils.response_code_matches(resp.status_code, 200):
+                from ..models.quarantined_registration import (
+                    QuarantinedRegistration,
+                )
+
+                return parsers.JsonResponseParser(
+                    rqa.List(parsers.ParserFor.make(QuarantinedRegistration))
+                ).try_parse(resp)
+
+            from ..models.any_error import AnyErrorParser
+
+            raise utils.get_error(
+                resp, (((400, 409, 401, 403, 404, 429, 500), AnyErrorParser),)
+            )
+
+        return paginated.Response(do_request, parse_response)
+
+    def unarchive(
+        self: QuarantinedRegistrationService[client.AuthenticatedClient],
+        *,
+        quarantined_registration_id: str,
+    ) -> None:
+        """Restore an archived quarantined registration to the active board.
+
+        :param quarantined_registration_id: Registration id to unarchive.
+
+        :returns: An empty response with return code 204
+        """
+
+        url = "/api/v1/quarantined_registrations/{quarantinedRegistrationId}/unarchive".format(
+            quarantinedRegistrationId=quarantined_registration_id
+        )
+        params = None
+
+        with self.__client as client:
+            resp = client.http.post(url=url, params=params)
+        utils.log_warnings(resp)
+
+        if utils.response_code_matches(resp.status_code, 204):
+            return parsers.ConstantlyParser(None).try_parse(resp)
+
+        from ..models.any_error import AnyErrorParser
+
+        raise utils.get_error(
+            resp, (((400, 409, 401, 403, 404, 429, 500), AnyErrorParser),)
+        )

{codegrade-17.0.67 → codegrade-17.0.68}/src/codegrade/client.py

@@ -661,7 +661,7 @@ class Client(_BaseClient):
         return httpx.Client(
             base_url=self.base_url,
             headers={
-                "User-Agent": "CodeGradeAPI/17.0.67",
+                "User-Agent": "CodeGradeAPI/17.0.68",
             },
             follow_redirects=True,
             transport=RetryingTransport(httpx.HTTPTransport()),
@@ -682,7 +682,7 @@ class AuthenticatedClient(_BaseClient):
             base_url=self.base_url,
             headers={
                 "Authorization": f"Bearer {self.token}",
-                "User-Agent": "CodeGradeAPI/17.0.67",
+                "User-Agent": "CodeGradeAPI/17.0.68",
             },
             follow_redirects=True,
             transport=RetryingTransport(httpx.HTTPTransport()),

{codegrade-17.0.67 → codegrade-17.0.68}/src/codegrade/models/__init__.py

@@ -38,6 +38,9 @@ from .any_non_redacted_auto_test_step_as_json import (
 )
 from .any_redacted_auto_test_step_as_json import AnyRedactedAutoTestStepAsJSON
 from .api_codes import APICodes as APICodes
+from .archive_quarantined_registration_data import (
+    ArchiveQuarantinedRegistrationData,
+)
 from .assignment import Assignment
 from .assignment_anonymization_algo import (
     AssignmentAnonymizationAlgo as AssignmentAnonymizationAlgo,

codegrade-17.0.68/src/codegrade/models/archive_quarantined_registration_data.py

@@ -0,0 +1,53 @@
+"""The module that defines the ``ArchiveQuarantinedRegistrationData`` model.
+
+SPDX-License-Identifier: AGPL-3.0-only OR BSD-3-Clause-Clear
+"""
+
+from __future__ import annotations
+
+import typing as t
+from dataclasses import dataclass, field
+
+import cg_request_args as rqa
+
+from ..utils import to_dict
+
+
+@dataclass(kw_only=True)
+class ArchiveQuarantinedRegistrationData:
+    """Input data required for the `Quarantined Registration::Archive`
+    operation.
+    """
+
+    #: Archive all active registrations with this email address.
+    email: str
+
+    raw_data: t.Optional[t.Dict[str, t.Any]] = field(init=False, repr=False)
+
+    data_parser: t.ClassVar[t.Any] = rqa.Lazy(
+        lambda: rqa.FixedMapping(
+            rqa.RequiredArgument(
+                "email",
+                rqa.SimpleValue.str,
+                doc="Archive all active registrations with this email address.",
+            ),
+        )
+    )
+
+    def to_dict(self) -> t.Dict[str, t.Any]:
+        res: t.Dict[str, t.Any] = {
+            "email": to_dict(self.email),
+        }
+        return res
+
+    @classmethod
+    def from_dict(
+        cls: t.Type[ArchiveQuarantinedRegistrationData], d: t.Dict[str, t.Any]
+    ) -> ArchiveQuarantinedRegistrationData:
+        parsed = cls.data_parser.try_parse(d)
+
+        res = cls(
+            email=parsed.email,
+        )
+        res.raw_data = d
+        return res

{codegrade-17.0.67 → codegrade-17.0.68}/src/codegrade/models/quarantined_registration.py

@@ -28,6 +28,9 @@ class QuarantinedRegistration:
     name: str
     #: The time this result was created
     created_at: datetime.datetime
+    #: When this registration was archived, or `None` if it is still an active
+    #: quarantined registration.
+    archived_at: t.Optional[datetime.datetime]
 
     raw_data: t.Optional[t.Dict[str, t.Any]] = field(init=False, repr=False)
 
@@ -58,6 +61,11 @@ class QuarantinedRegistration:
                 rqa.RichValue.DateTime,
                 doc="The time this result was created",
             ),
+            rqa.RequiredArgument(
+                "archived_at",
+                rqa.Nullable(rqa.RichValue.DateTime),
+                doc="When this registration was archived, or `None` if it is still an active quarantined registration.",
+            ),
         )
     )
 
@@ -68,6 +76,7 @@ class QuarantinedRegistration:
             "username": to_dict(self.username),
             "name": to_dict(self.name),
             "created_at": to_dict(self.created_at),
+            "archived_at": to_dict(self.archived_at),
         }
         return res
 
@@ -83,6 +92,7 @@ class QuarantinedRegistration:
             username=parsed.username,
             name=parsed.name,
             created_at=parsed.created_at,
+            archived_at=parsed.archived_at,
         )
         res.raw_data = d
         return res

codegrade-17.0.67/src/codegrade/_api/quarantined_registration.py

@@ -1,160 +0,0 @@
-"""The endpoints for quarantined_registration objects.
-
-SPDX-License-Identifier: AGPL-3.0-only OR BSD-3-Clause-Clear
-"""
-
-from __future__ import annotations
-
-import os
-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
-
-if t.TYPE_CHECKING or os.getenv("CG_EAGERIMPORT", False):
-    from .. import client
-    from ..models.accept_quarantined_registration_data import (
-        AcceptQuarantinedRegistrationData,
-    )
-    from ..models.deny_quarantined_registration_data import (
-        DenyQuarantinedRegistrationData,
-    )
-    from ..models.quarantined_registration import QuarantinedRegistration
-
-
-_ClientT = t.TypeVar("_ClientT", bound="client._BaseClient")
-
-
-class QuarantinedRegistrationService(t.Generic[_ClientT]):
-    __slots__ = ("__client",)
-
-    def __init__(self, client: _ClientT) -> None:
-        self.__client = client
-
-    def accept(
-        self: QuarantinedRegistrationService[client.AuthenticatedClient],
-        json_body: AcceptQuarantinedRegistrationData,
-        *,
-        quarantined_registration_id: str,
-    ) -> None:
-        """Accept quarantined registrations.
-
-        :param json_body: The body of the request. See
-            :class:`.AcceptQuarantinedRegistrationData` for information about
-            the possible fields. You can provide this data as a
-            :class:`.AcceptQuarantinedRegistrationData` or as a dictionary.
-        :param quarantined_registration_id: Registration id to accept.
-
-        :returns: An empty response with return code 204
-        """
-
-        url = "/api/v1/quarantined_registrations/{quarantinedRegistrationId}/accept".format(
-            quarantinedRegistrationId=quarantined_registration_id
-        )
-        params = None
-
-        with self.__client as client:
-            resp = client.http.post(
-                url=url, json=utils.to_dict(json_body), params=params
-            )
-        utils.log_warnings(resp)
-
-        if utils.response_code_matches(resp.status_code, 204):
-            return parsers.ConstantlyParser(None).try_parse(resp)
-
-        from ..models.any_error import AnyErrorParser
-
-        raise utils.get_error(
-            resp, (((400, 409, 401, 403, 404, 429, 500), AnyErrorParser),)
-        )
-
-    def deny(
-        self: QuarantinedRegistrationService[client.AuthenticatedClient],
-        json_body: DenyQuarantinedRegistrationData,
-        *,
-        quarantined_registration_id: str,
-    ) -> None:
-        """Deny quarantined registrations.
-
-        :param json_body: The body of the request. See
-            :class:`.DenyQuarantinedRegistrationData` for information about the
-            possible fields. You can provide this data as a
-            :class:`.DenyQuarantinedRegistrationData` or as a dictionary.
-        :param quarantined_registration_id: Registration id to accept.
-
-        :returns: An empty response with return code 204
-        """
-
-        url = "/api/v1/quarantined_registrations/{quarantinedRegistrationId}/deny".format(
-            quarantinedRegistrationId=quarantined_registration_id
-        )
-        params = None
-
-        with self.__client as client:
-            resp = client.http.post(
-                url=url, json=utils.to_dict(json_body), params=params
-            )
-        utils.log_warnings(resp)
-
-        if utils.response_code_matches(resp.status_code, 204):
-            return parsers.ConstantlyParser(None).try_parse(resp)
-
-        from ..models.any_error import AnyErrorParser
-
-        raise utils.get_error(
-            resp, (((400, 409, 401, 403, 404, 429, 500), AnyErrorParser),)
-        )
-
-    def get_all(
-        self: QuarantinedRegistrationService[client.AuthenticatedClient],
-        *,
-        page_size: int = 25,
-    ) -> paginated.Response[QuarantinedRegistration]:
-        """List quarantined registrations.
-
-        :param page_size: The size of a single page, maximum is 100.
-
-        :returns: Paginated list of quarantined registrations.
-        """
-
-        url = "/api/v1/quarantined_registrations/"
-        params: t.Dict[str, str | int | bool] = {
-            "page-size": page_size,
-        }
-
-        if t.TYPE_CHECKING:
-            import httpx
-
-        def do_request(next_token: str | None) -> httpx.Response:
-            if next_token is None:
-                params.pop("next-token", "")
-            else:
-                params["next-token"] = next_token
-            with self.__client as client:
-                resp = client.http.get(url=url, params=params)
-            utils.log_warnings(resp)
-
-            return resp
-
-        def parse_response(
-            resp: httpx.Response,
-        ) -> t.Sequence[QuarantinedRegistration]:
-            if utils.response_code_matches(resp.status_code, 200):
-                from ..models.quarantined_registration import (
-                    QuarantinedRegistration,
-                )
-
-                return parsers.JsonResponseParser(
-                    rqa.List(parsers.ParserFor.make(QuarantinedRegistration))
-                ).try_parse(resp)
-
-            from ..models.any_error import AnyErrorParser
-
-            raise utils.get_error(
-                resp, (((400, 409, 401, 403, 404, 429, 500), AnyErrorParser),)
-            )
-
-        return paginated.Response(do_request, parse_response)