codegrade 16.1.86__tar.gz → 16.1.89__tar.gz

{codegrade-16.1.86 → codegrade-16.1.89}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: codegrade
-Version: 16.1.86
+Version: 16.1.89
 Summary: A client library for accessing CodeGrade
 License: AGPL-3.0-only OR BSD-3-Clause-Clear
 Requires-Python: >=3.9.0,<4.0

{codegrade-16.1.86 → codegrade-16.1.89}/cg_request_args/_rich_value.py

@@ -2,6 +2,7 @@
 This module contains parsers for values that should be transformed or
 restricted in any way.
 """
+
 import re
 import uuid
 import typing as t
@@ -27,15 +28,15 @@ class _GEComparable(Protocol):
         ...
 
 
-_GEComparableT = t.TypeVar('_GEComparableT', bound=_GEComparable)
+_GEComparableT = t.TypeVar("_GEComparableT", bound=_GEComparable)
 
-__all__ = ('RichValue', )
+__all__ = ("RichValue", )
 
 
 class _NumberAsString(_Transform[int, str]):
     __slots__ = ()
 
-    def __init__(self, name: str = '_NumberAsString') -> None:
+    def __init__(self, name: str = "_NumberAsString") -> None:
         super().__init__(
             SimpleValue.str,
             self.__to_int,
@@ -56,12 +57,12 @@ class _UUID(_Transform[uuid.UUID, str]):
     __slots__ = ()
 
     def __init__(self) -> None:
-        super().__init__(SimpleValue.str, self.__transform_to_uuid, 'UUID')
+        super().__init__(SimpleValue.str, self.__transform_to_uuid, "UUID")
 
     def _to_open_api(self, schema: OpenAPISchema) -> t.Mapping[str, t.Any]:
         return {
             **self._parser.to_open_api(schema),
-            'format': 'uuid',
+            "format": "uuid",
         }
 
     def __transform_to_uuid(self, value: str) -> uuid.UUID:
@@ -72,7 +73,7 @@ class _UUID(_Transform[uuid.UUID, str]):
                 self,
                 value,
                 extra={
-                    'message': "which can't be parsed as a valid uuid",
+                    "message": "which can't be parsed as a valid uuid",
                 },
             ) from exc
 
@@ -81,23 +82,23 @@ class _Date(_Transform[datetime.date, str]):
     __slots__ = ()
 
     _ISO8601_DATE_RE = re.compile(
-        r'^(?P<year>\d+)-(?P<month>\d\d)-(?P<day>\d\d)$'
+        r"^(?P<year>\d+)-(?P<month>\d\d)-(?P<day>\d\d)$"
     )
 
     def __init__(self) -> None:
-        super().__init__(SimpleValue.str, self.__transform_to_date, 'Date')
+        super().__init__(SimpleValue.str, self.__transform_to_date, "Date")
 
     def _to_open_api(self, schema: OpenAPISchema) -> t.Mapping[str, t.Any]:
         return {
             **self._parser.to_open_api(schema),
-            'format': 'date',
+            "format": "date",
         }
 
     def __transform_to_date(self, value: str) -> datetime.date:
         match = self._ISO8601_DATE_RE.match(value)
         if match is None:
             raise SimpleParseError(self, value)
-        year, month, day = map(int, match.group('year', 'month', 'day'))
+        year, month, day = map(int, match.group("year", "month", "day"))
         try:
             return datetime.date(year=year, month=month, day=day)
         except ValueError as exc:
@@ -109,17 +110,18 @@ class _DateTime(_Transform[DatetimeWithTimezone, str]):
 
     def __init__(self) -> None:
         super().__init__(
-            SimpleValue.str, self.__transform_to_datetime, 'DateTime'
+            SimpleValue.str, self.__transform_to_datetime, "DateTime"
         )
 
     def _to_open_api(self, schema: OpenAPISchema) -> t.Mapping[str, t.Any]:
         return {
             **self._parser.to_open_api(schema),
-            'format': 'date-time',
+            "format": "date-time",
         }
 
     def __transform_to_datetime(self, value: str) -> DatetimeWithTimezone:
         import dateutil.parser
+
         try:
             parsed = dateutil.parser.isoparse(value)
         except (ValueError, OverflowError) as exc:
@@ -127,7 +129,7 @@ class _DateTime(_Transform[DatetimeWithTimezone, str]):
                 self,
                 value,
                 extra={
-                    'message': "which can't be parsed as a valid datetime",
+                    "message": "which can't be parsed as a valid datetime",
                 },
             ) from exc
         else:
@@ -154,7 +156,7 @@ class _EmailList(_Constraint[str]):
 
     @property
     def name(self) -> str:
-        return 'as email list'
+        return "as email list"
 
 
 class _Password(SimpleValueFactory[str]):
@@ -164,12 +166,12 @@ class _Password(SimpleValueFactory[str]):
         super().__init__(str)
 
     def describe(self) -> str:
-        return f'password as {super().describe()}'
+        return f"password as {super().describe()}"
 
     def _to_open_api(self, schema: OpenAPISchema) -> t.Mapping[str, t.Any]:
         return {
             **super()._to_open_api(schema),
-            'format': 'password',
+            "format": "password",
         }
 
     def try_parse(self, value: object) -> str:
@@ -177,38 +179,38 @@ class _Password(SimpleValueFactory[str]):
             return super().try_parse(value)
         except ParseError:
             # Don't raise from as that might leak the value
-            raise SimpleParseError(self, found='REDACTED')  # pylint: disable=raise-missing-from
+            raise SimpleParseError(self, found="REDACTED")  # pylint: disable=raise-missing-from
 
 
 class _TimeDeltaFactory(_Transform[datetime.timedelta, t.Union[str, float]]):
-    """Factory to create a ISO timedelta parser.
-    """
+    """Factory to create a ISO timedelta parser."""
+
     __slots__ = ()
 
     # The regex below are copied from Pydantic
     _ISO8601_DURATION_RE = re.compile(
-        r'^(?P<sign>[-+]?)'
-        r'P'
-        r'(?:(?P<days>\d+(.\d+)?)D)?'
-        r'(?:T'
-        r'(?:(?P<hours>\d+(.\d+)?)H)?'
-        r'(?:(?P<minutes>\d+(.\d+)?)M)?'
-        r'(?:(?P<seconds>\d+(.\d+)?)S)?'
-        r')?'
-        r'$'
+        r"^(?P<sign>[-+]?)"
+        r"P"
+        r"(?:(?P<days>\d+(.\d+)?)D)?"
+        r"(?:T"
+        r"(?:(?P<hours>\d+(.\d+)?)H)?"
+        r"(?:(?P<minutes>\d+(.\d+)?)M)?"
+        r"(?:(?P<seconds>\d+(.\d+)?)S)?"
+        r")?"
+        r"$"
     )
 
     def __init__(self, parser: Parser[t.Union[str, float]]) -> None:
         super().__init__(
             parser,
             self.__to_timedelta,
-            'TimeDelta',
+            "TimeDelta",
         )
 
     def _to_open_api(self, schema: OpenAPISchema) -> t.Mapping[str, t.Any]:
         return {
             **SimpleValue.float.to_open_api(schema),
-            'format': 'time-delta',
+            "format": "time-delta",
         }
 
     def __to_timedelta(self, value: t.Union[str, float]) -> datetime.timedelta:
@@ -223,14 +225,14 @@ class _TimeDeltaFactory(_Transform[datetime.timedelta, t.Union[str, float]]):
 
         groupdict: t.Mapping[str, t.Optional[str]] = match.groupdict()
         groups = {k: v for k, v in groupdict.items() if v is not None}
-        sign = -1 if groups.get('sign', None) == '-' else 1
+        sign = -1 if groups.get("sign", None) == "-" else 1
 
         return sign * datetime.timedelta(
-            days=float(groups.get('days', 0)),
-            hours=float(groups.get('hours', 0)),
-            minutes=float(groups.get('minutes', 0)),
-            seconds=float(groups.get('seconds', 0)),
-            microseconds=float(groups.get('microseconds', 0)),
+            days=float(groups.get("days", 0)),
+            hours=float(groups.get("hours", 0)),
+            minutes=float(groups.get("minutes", 0)),
+            seconds=float(groups.get("seconds", 0)),
+            microseconds=float(groups.get("microseconds", 0)),
         )
 
 
@@ -247,7 +249,7 @@ class _NonEmptyString(SimpleValueFactory[str]):
                 self,
                 value,
                 extra={
-                    'message': "which is empty",
+                    "message": "which is empty",
                 },
             )
         return nonempty
@@ -260,27 +262,29 @@ class _StringWithoutNullByte(SimpleValueFactory[str]):
         super().__init__(str)
 
     def try_parse(self, value: object) -> str:
-        return super().try_parse(value).replace('\0', '')
+        return super().try_parse(value).replace("\0", "")
 
 
 class _Fraction(Parser[fractions.Fraction]):
     __slots__ = ()
 
-    _SUB_PARSER = FixedMapping(
-        RequiredArgument(
-            'n',
-            _NumberAsString(),
-            'The numerator of the rational.',
-        ),
-        RequiredArgument(
-            'd',
-            _NumberAsString(),
-            'The denominator of the rational.',
-        ),
-    ).as_schema('Fraction').add_open_api_metadata('x-is-fraction', True)
+    _SUB_PARSER = (
+        FixedMapping(
+            RequiredArgument(
+                "n",
+                _NumberAsString(),
+                "The numerator of the rational.",
+            ),
+            RequiredArgument(
+                "d",
+                _NumberAsString(),
+                "The denominator of the rational.",
+            ),
+        ).as_schema("Fraction").add_open_api_metadata("x-is-fraction", True)
+    )
 
     def describe(self) -> str:
-        return 'Fraction'
+        return "Fraction"
 
     def _to_open_api(self, schema: t.Any) -> t.Mapping[str, t.Any]:
         return self._SUB_PARSER.to_open_api(schema)
@@ -293,22 +297,22 @@ class _Fraction(Parser[fractions.Fraction]):
 class _Decimal(_Transform[decimal.Decimal, str]):
     __slots__ = ()
 
-    _REGEX = r'^[+-]?\d+([.]\d+)?$'
+    _REGEX = r"^[+-]?\d+([.]\d+)?$"
     _COMPILED_REGEX = re.compile(_REGEX)
 
     def __init__(self) -> None:
         super().__init__(
             parser=SimpleValue.str,
             transform=self._transform,
-            transform_name='Decimal',
+            transform_name="Decimal",
         )
 
     def _to_open_api(self, schema: t.Any) -> t.Mapping[str, t.Any]:
         base = self._parser.to_open_api(schema)
         return {
             **base,
-            'pattern': self._REGEX,
-            'format': 'decimal',
+            "pattern": self._REGEX,
+            "format": "decimal",
         }
 
     def _transform(self, value: str) -> decimal.Decimal:
@@ -347,9 +351,9 @@ class RichValue:
     Fraction = _Fraction()
 
     class ValueGte(_Constraint[_GEComparableT], t.Generic[_GEComparableT]):
-        """Parse a number that is gte than a given minimum.
-        """
-        __slots__ = ('__minimum', )
+        """Parse a number that is gte than a given minimum."""
+
+        __slots__ = ("__minimum", )
 
         def __init__(
             self, parser: Parser[_GEComparableT], minimum: _GEComparableT
@@ -359,7 +363,7 @@ class RichValue:
 
         @property
         def name(self) -> str:
-            return f'larger than {self.__minimum}'
+            return f"larger than {self.__minimum}"
 
         def ok(self, value: _GEComparableT) -> bool:
             return value >= self.__minimum
@@ -367,5 +371,5 @@ class RichValue:
         def _to_open_api(self, schema: OpenAPISchema) -> t.Mapping[str, t.Any]:
             return {
                 **self._parser.to_open_api(schema),
-                'minimum': self.__minimum,
+                "minimum": self.__minimum,
             }

{codegrade-16.1.86 → codegrade-16.1.89}/codegrade/__init__.py

@@ -8,7 +8,7 @@ from functools import wraps
 from .client import AuthenticatedClient, Client
 
 __all__ = ("login", "AuthenticatedClient", "Client", "login_from_cli")
-__version__ = "16.1.86"
+__version__ = "16.1.89"
 
 
 @wraps(AuthenticatedClient.get)
@@ -21,6 +21,11 @@ def login_from_cli(*args, **kwargs):
     return AuthenticatedClient.get_from_cli(*args, **kwargs)
 
 
+@wraps(AuthenticatedClient.get_from_cli_for_course)
+def login_from_cli_for_course(*args, **kwargs):
+    return AuthenticatedClient.get_from_cli_for_course(*args, **kwargs)
+
+
 login.__name__ = "login"
 login.__doc__ = """Get an :class:`.AuthenticatedClient` by logging in with your
     username and password.

{codegrade-16.1.86 → codegrade-16.1.89}/codegrade/_api/file.py

@@ -94,6 +94,7 @@ class FileService(t.Generic[_ClientT]):
         *,
         max_age: Maybe["int"] = Nothing,
         filename: "str" = "uploaded_file",
+        ephemeral: "bool" = False,
         extra_parameters: t.Optional[
             t.Mapping[str, t.Union[str, bool, int, float]]
         ] = None,
@@ -103,6 +104,9 @@ class FileService(t.Generic[_ClientT]):
         :param max_age: The maximum amount of time (in seconds) this file will
             stay valid and can be retrieved.
         :param filename: The name of the uploaded file.
+        :param ephemeral: If set this file will be never saved to persistent
+            storage. The maximum size of file that can be uploaded like this is
+            1mb.
         :param extra_parameters: The extra query parameters you might want to
             add. By default no extra query parameters are added.
 
@@ -113,6 +117,7 @@ class FileService(t.Generic[_ClientT]):
         params: t.Dict[str, t.Any] = {
             **(extra_parameters or {}),
             "filename": utils.to_dict(filename),
+            "ephemeral": utils.to_dict(ephemeral),
         }
         maybe_from_nullable(t.cast(t.Any, max_age)).if_just(
             lambda val: params.__setitem__("max_age", val)

{codegrade-16.1.86 → codegrade-16.1.89}/codegrade/_api/login_link.py

@@ -15,9 +15,7 @@ if t.TYPE_CHECKING or os.getenv("CG_EAGERIMPORT", False):
     import codegrade
 
     from ..models.assignment_login_link import AssignmentLoginLink
-    from ..models.result_data_post_login_link_login import (
-        ResultDataPostLoginLinkLogin,
-    )
+    from ..models.user_login_response import UserLoginResponse
 
 
 _ClientT = t.TypeVar("_ClientT", bound="codegrade.client._BaseClient")
@@ -84,7 +82,7 @@ class LoginLinkService(t.Generic[_ClientT]):
         extra_parameters: t.Optional[
             t.Mapping[str, t.Union[str, bool, int, float]]
         ] = None,
-    ) -> "ResultDataPostLoginLinkLogin":
+    ) -> "UserLoginResponse":
         """Login with the given login link.
 
         This will only work when the assignment connected to this link is
@@ -114,13 +112,11 @@ class LoginLinkService(t.Generic[_ClientT]):
 
         if utils.response_code_matches(resp.status_code, 200):
             # fmt: off
-            from ..models.result_data_post_login_link_login import (
-                ResultDataPostLoginLinkLogin,
-            )
+            from ..models.user_login_response import UserLoginResponse
 
             # fmt: on
             return parsers.JsonResponseParser(
-                parsers.ParserFor.make(ResultDataPostLoginLinkLogin)
+                parsers.ParserFor.make(UserLoginResponse)
             ).try_parse(resp)
 
         from ..models.any_error import AnyError

{codegrade-16.1.86 → codegrade-16.1.89}/codegrade/_api/user.py

@@ -23,10 +23,6 @@ if t.TYPE_CHECKING or os.getenv("CG_EAGERIMPORT", False):
     from ..models.logout_user_data import LogoutUserData
     from ..models.patch_user_data import PatchUserData
     from ..models.register_user_data import RegisterUserData
-    from ..models.result_data_post_user_login import ResultDataPostUserLogin
-    from ..models.result_data_post_user_register import (
-        ResultDataPostUserRegister,
-    )
     from ..models.session_restriction_data import SessionRestrictionData
     from ..models.tenant_coupon_usage import TenantCouponUsage
     from ..models.user import User
@@ -262,7 +258,7 @@ class UserService(t.Generic[_ClientT]):
         extra_parameters: t.Optional[
             t.Mapping[str, t.Union[str, bool, int, float]]
         ] = None,
-    ) -> "ResultDataPostUserLogin":
+    ) -> "UserLoginResponse":
         """Login using your username and password.
 
         `permissions` to the user. The value will be a mapping indicating which
@@ -293,13 +289,11 @@ class UserService(t.Generic[_ClientT]):
 
         if utils.response_code_matches(resp.status_code, 200):
             # fmt: off
-            from ..models.result_data_post_user_login import (
-                ResultDataPostUserLogin,
-            )
+            from ..models.user_login_response import UserLoginResponse
 
             # fmt: on
             return parsers.JsonResponseParser(
-                parsers.ParserFor.make(ResultDataPostUserLogin)
+                parsers.ParserFor.make(UserLoginResponse)
             ).try_parse(resp)
 
         from ..models.any_error import AnyError
@@ -321,7 +315,7 @@ class UserService(t.Generic[_ClientT]):
         extra_parameters: t.Optional[
             t.Mapping[str, t.Union[str, bool, int, float]]
         ] = None,
-    ) -> "ResultDataPostUserRegister":
+    ) -> "UserLoginResponse":
         """Create a new user.
 
         :param json_body: The body of the request. See
@@ -346,13 +340,11 @@ class UserService(t.Generic[_ClientT]):
 
         if utils.response_code_matches(resp.status_code, 200):
             # fmt: off
-            from ..models.result_data_post_user_register import (
-                ResultDataPostUserRegister,
-            )
+            from ..models.user_login_response import UserLoginResponse
 
             # fmt: on
             return parsers.JsonResponseParser(
-                parsers.ParserFor.make(ResultDataPostUserRegister)
+                parsers.ParserFor.make(UserLoginResponse)
             ).try_parse(resp)
 
         from ..models.any_error import AnyError

{codegrade-16.1.86 → codegrade-16.1.89}/codegrade/client.py

@@ -11,8 +11,12 @@ import typing as t
 import uuid
 from types import TracebackType
 
+import cg_maybe
 import httpx
 
+from codegrade.models import CoursePermission as _CoursePermission
+from codegrade.models import SessionRestrictionData as _SessionRestrictionData
+
 from .utils import maybe_input, select_from_list
 
 _DEFAULT_HOST = os.getenv("CG_HOST", "https://app.codegra.de")
@@ -539,7 +543,7 @@ class Client(_BaseClient):
         return httpx.Client(
             base_url=self.base_url,
             headers={
-                "User-Agent": "CodeGradeAPI/16.1.86",
+                "User-Agent": "CodeGradeAPI/16.1.89",
             },
             follow_redirects=True,
         )
@@ -559,7 +563,7 @@ class AuthenticatedClient(_BaseClient):
             base_url=self.base_url,
             headers={
                 "Authorization": f"Bearer {self.token}",
-                "User-Agent": "CodeGradeAPI/16.1.86",
+                "User-Agent": "CodeGradeAPI/16.1.89",
             },
             follow_redirects=True,
         )
@@ -702,3 +706,63 @@ class AuthenticatedClient(_BaseClient):
         return cls.get(
             username=username, password=password, host=host, tenant=tenant.id
         )
+
+    def restrict(
+        client,
+        *,
+        course_id: t.Optional[int] = None,
+        removed_permissions: t.Sequence[_CoursePermission] = (),
+    ) -> None:
+        """Restrict this authenticated client to a specific course and/or
+        reduced permissions.
+
+        :param course_id: If provided, restrict access to only this course.
+        :param removed_permissions: If provided, remove specific permissions in
+            the current session.
+        """
+        restriction = _SessionRestrictionData(
+            for_context=cg_maybe.from_nullable(course_id).map(
+                lambda cid: {"course_id": cid}
+            ),
+            removed_permissions=(
+                cg_maybe.of({"course": removed_permissions})
+                if removed_permissions
+                else cg_maybe.Nothing
+            ),
+        )
+
+        restricted_login = client.user.restrict(restriction)
+        client.user.logout({"token": client.token})
+        client.token = restricted_login.access_token
+        client.http.headers["Authorization"] = f"Bearer {client.token}"
+
+    @classmethod
+    def get_from_cli_for_course(
+        cls, course_id: t.Optional[int] = None
+    ) -> "AuthenticatedClient":
+        """Get an :class:`.AuthenticatedClient` by logging in through command
+        line interface for a specific course.
+
+        :param course_id: The optional ID of the course you want to log into.
+
+        :returns: A new ``AuthenticatedClient``.
+        """
+        client = cls.get_from_cli()
+
+        if course_id is not None:
+            client.restrict(course_id=course_id, removed_permissions=[])
+            return client
+
+        course = select_from_list(
+            "Select your course",
+            # Sort so that the newest course will be at the bottom, supporting
+            # the common case of selecting one of the latest courses.
+            sorted(
+                client.course.get_all(extended=False, limit=cg_maybe.of(200)),
+                key=lambda c: c.created_at,
+            ),
+            lambda c: c.name,
+        ).try_extract(sys.exit)
+
+        client.restrict(course_id=course.id, removed_permissions=[])
+        return client

{codegrade-16.1.86 → codegrade-16.1.89}/codegrade/models/__init__.py

@@ -446,9 +446,6 @@ from .lti1p3_system_role_from_context_role_setting import (
     Lti1p3SystemRoleFromContextRoleSetting,
 )
 from .lti_enabled_setting import LtiEnabledSetting
-from .lti_first_launch_content_id_enabled_setting import (
-    LtiFirstLaunchContentIdEnabledSetting,
-)
 from .lti_launch_data_logging_setting import LtiLaunchDataLoggingSetting
 from .lti_lock_date_copying_enabled_setting import (
     LtiLockDateCopyingEnabledSetting,
@@ -639,12 +636,9 @@ from .repository_connection_limit_reached_exception import (
 from .reset_token_time_setting import ResetTokenTimeSetting
 from .result_data_get_auto_test_get import ResultDataGetAutoTestGet
 from .result_data_get_task_result_get_all import ResultDataGetTaskResultGetAll
-from .result_data_post_login_link_login import ResultDataPostLoginLinkLogin
 from .result_data_post_section_create_division import (
     ResultDataPostSectionCreateDivision,
 )
-from .result_data_post_user_login import ResultDataPostUserLogin
-from .result_data_post_user_register import ResultDataPostUserRegister
 from .retry_group_submission_grade_passback_enabled_setting import (
     RetryGroupSubmissionGradePassbackEnabledSetting,
 )

{codegrade-16.1.86 → codegrade-16.1.89}/codegrade/models/all_site_settings.py

@@ -118,10 +118,6 @@ class AllSiteSettings(FrontendSiteSettings):
     #: Prefer the most privileged role in the LTI 1.3 roles claim sent by the
     #: LMS, instead of the first role that matches any of our definitions.
     lti_1p3_parse_most_privileged_role: Maybe["bool"] = Nothing
-    #: Whether we act upon the custom claims parameter for content id, which we
-    #: then use to import an item from the community library. This feature
-    #: enables that we check for this content id in the launch parameters.
-    lti_first_launch_content_id_enabled: Maybe["bool"] = Nothing
     #: Enable logging of LTI launch data. NEVER ENABLE THIS SITE-WIDE, only for
     #: a single tenant, and disable this feature after you've gotten the data
     #: you need.
@@ -320,11 +316,6 @@ class AllSiteSettings(FrontendSiteSettings):
                     rqa.SimpleValue.bool,
                     doc="Prefer the most privileged role in the LTI 1.3 roles claim sent by the LMS, instead of the first role that matches any of our definitions.",
                 ),
-                rqa.OptionalArgument(
-                    "LTI_FIRST_LAUNCH_CONTENT_ID_ENABLED",
-                    rqa.SimpleValue.bool,
-                    doc="Whether we act upon the custom claims parameter for content id, which we then use to import an item from the community library. This feature enables that we check for this content id in the launch parameters.",
-                ),
                 rqa.OptionalArgument(
                     "LTI_LAUNCH_DATA_LOGGING",
                     rqa.SimpleValue.bool,
@@ -468,9 +459,6 @@ class AllSiteSettings(FrontendSiteSettings):
         self.lti_1p3_parse_most_privileged_role = maybe_from_nullable(
             self.lti_1p3_parse_most_privileged_role
         )
-        self.lti_first_launch_content_id_enabled = maybe_from_nullable(
-            self.lti_first_launch_content_id_enabled
-        )
         self.lti_launch_data_logging = maybe_from_nullable(
             self.lti_launch_data_logging
         )
@@ -1028,10 +1016,6 @@ class AllSiteSettings(FrontendSiteSettings):
             res["LTI_1P3_PARSE_MOST_PRIVILEGED_ROLE"] = to_dict(
                 self.lti_1p3_parse_most_privileged_role.value
             )
-        if self.lti_first_launch_content_id_enabled.is_just:
-            res["LTI_FIRST_LAUNCH_CONTENT_ID_ENABLED"] = to_dict(
-                self.lti_first_launch_content_id_enabled.value
-            )
         if self.lti_launch_data_logging.is_just:
             res["LTI_LAUNCH_DATA_LOGGING"] = to_dict(
                 self.lti_launch_data_logging.value
@@ -1214,7 +1198,6 @@ class AllSiteSettings(FrontendSiteSettings):
             lti_unset_deadline_lock_date_enabled=parsed.LTI_UNSET_DEADLINE_LOCK_DATE_ENABLED,
             lti_1p3_system_role_from_context_role=parsed.LTI_1P3_SYSTEM_ROLE_FROM_CONTEXT_ROLE,
             lti_1p3_parse_most_privileged_role=parsed.LTI_1P3_PARSE_MOST_PRIVILEGED_ROLE,
-            lti_first_launch_content_id_enabled=parsed.LTI_FIRST_LAUNCH_CONTENT_ID_ENABLED,
             lti_launch_data_logging=parsed.LTI_LAUNCH_DATA_LOGGING,
             pearson_templates=parsed.PEARSON_TEMPLATES,
             default_course_teacher_role=parsed.DEFAULT_COURSE_TEACHER_ROLE,

{codegrade-16.1.86 → codegrade-16.1.89}/codegrade/models/base_lms_capabilities.py

@@ -43,6 +43,8 @@ class BaseLMSCapabilities:
     #: Should the name of the assignment be set within CodeGrade and not copied
     #: from the LMS?
     set_name: "bool"
+    #: Are we allowed to set the max attempts within CodeGrade.
+    set_max_attempts: "bool"
     #: The name of the iframe `postMessage` we can send to the LMS to notify
     #: that we want to set cookies in a full window.  This property is ugly,
     #: and shows that these capabilities are not really a very good
@@ -115,6 +117,11 @@ class BaseLMSCapabilities:
                 rqa.SimpleValue.bool,
                 doc="Should the name of the assignment be set within CodeGrade and not copied from the LMS?",
             ),
+            rqa.RequiredArgument(
+                "set_max_attempts",
+                rqa.SimpleValue.bool,
+                doc="Are we allowed to set the max attempts within CodeGrade.",
+            ),
             rqa.RequiredArgument(
                 "cookie_post_message",
                 rqa.Nullable(rqa.SimpleValue.str),
@@ -151,6 +158,7 @@ class BaseLMSCapabilities:
             "set_state": to_dict(self.set_state),
             "set_available_at": to_dict(self.set_available_at),
             "set_name": to_dict(self.set_name),
+            "set_max_attempts": to_dict(self.set_max_attempts),
             "cookie_post_message": to_dict(self.cookie_post_message),
             "supported_custom_replacement_groups": to_dict(
                 self.supported_custom_replacement_groups
@@ -176,6 +184,7 @@ class BaseLMSCapabilities:
             set_state=parsed.set_state,
             set_available_at=parsed.set_available_at,
             set_name=parsed.set_name,
+            set_max_attempts=parsed.set_max_attempts,
             cookie_post_message=parsed.cookie_post_message,
             supported_custom_replacement_groups=parsed.supported_custom_replacement_groups,
             use_id_in_urls=parsed.use_id_in_urls,