codegrade 16.1.61__tar.gz → 16.1.63__tar.gz

{codegrade-16.1.61 → codegrade-16.1.63}/PKG-INFO

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

{codegrade-16.1.61 → codegrade-16.1.63}/cg_request_args/__init__.py

@@ -1,6 +1,7 @@
 """This module defines parsers and validators for JSON data.
 """
 
+from ._set import Set
 from ._base import Union, Parser, SimpleValue
 from ._enum import EnumValue, StringEnum
 from ._form import FormURLEncoded
@@ -21,6 +22,6 @@ from ._multipart import (
 )
 from .exceptions import ParseError, SimpleParseError, MultipleParseErrors
 from ._rich_value import RichValue
-from ._swaggerize import swaggerize, process_query_params
+from ._swaggerize import swaggerize
 from ._parse_utils import Transform
 from ._swagger_utils import OpenAPISchema

{codegrade-16.1.61 → codegrade-16.1.63}/cg_request_args/_convert.py

@@ -12,6 +12,7 @@ import dataclasses
 
 from cg_dt_utils import DatetimeWithTimezone
 
+from ._set import Set
 from ._base import Parser, SimpleValue
 from ._enum import EnumValue, StringEnum
 from ._lazy import Lazy
@@ -423,3 +424,13 @@ def _convert_two_tuple(ctx: ConvertCtx) -> Parser:
         ctx.update_type(ctx.typ.__args__[0]).convert(),
         ctx.update_type(ctx.typ.__args__[1]).convert(),
     ).use_readable_describe(ctx.readable)
+
+
+@as_converter(
+    lambda x: x.origin == set,
+)
+def _convert_set(ctx: ConvertCtx) -> Parser:
+    ctx.assert_not_query()
+    return Set(
+        ctx.update_type(ctx.typ.__args__[0]).convert(),
+    ).use_readable_describe(ctx.readable)

{codegrade-16.1.61 → codegrade-16.1.63}/cg_request_args/_mapping.py

@@ -209,14 +209,14 @@ class _BaseFixedMapping(t.Generic[_BaseDictT]):
             content = ', '.join(args)
         return 'Mapping[{}]'.format(content)
 
-    def to_open_api_as_query(
-        self, schema: OpenAPISchema
+    def to_open_api_as_parameters(
+        self,
+        schema: OpenAPISchema,
     ) -> t.Sequence[t.Mapping[str, t.Any]]:
         """Convert this mapping to a OpenAPI object as if it were used as a
         query string.
         """
         return [{
-            'in': 'query',
             'name': arg.key,
             'schema': arg.to_open_api(schema),
             'description': schema.make_comment(arg.doc),

codegrade-16.1.63/cg_request_args/_set.py

@@ -0,0 +1,34 @@
+"""This module contains parsers for sets.
+"""
+import typing as t
+
+from ._base import Parser
+from ._list import List
+from ._utils import T_COV as _T_COV
+from ._swagger_utils import OpenAPISchema
+
+__all__ = ('Set', )
+
+
+class Set(t.Generic[_T_COV], Parser[set[_T_COV]]):
+    """A parser for a list homogeneous values.
+    """
+    __slots__ = ('__list_parser', )
+
+    def __init__(self, el_type: Parser[_T_COV]):
+        super().__init__()
+        self.__list_parser = List(el_type).add_open_api_metadata(
+            'x-is-set-type',
+            True,
+        )
+
+    def describe(self) -> str:
+        return self.__list_parser.describe()
+
+    def _to_open_api(self, schema: OpenAPISchema) -> t.Mapping[str, t.Any]:
+        return self.__list_parser.to_open_api(schema)
+
+    def try_parse(self, value: object) -> set[_T_COV]:
+        if isinstance(value, set):
+            value = list(value)
+        return set(self.__list_parser.try_parse(value))

{codegrade-16.1.61 → codegrade-16.1.63}/cg_request_args/_swaggerize.py

@@ -5,26 +5,23 @@ import inspect
 import functools
 import dataclasses
 
+from ._utils import T as _T
 from ._utils import Literal
 from ._mapping import BaseFixedMapping
 
 __all__ = ('swaggerize', )
 
+_P = t.ParamSpec('_P')
 _CallableT = t.TypeVar('_CallableT', bound=t.Callable)
 
 
-@dataclasses.dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True, slots=True, kw_only=True)
 class _SwaggerFunc:
-    __slots__ = (
-        'operation_name',
-        'no_data',
-        'func',
-        'query_parser',
-    )
     operation_name: str
     no_data: bool
     func: t.Callable
     query_parser: t.Optional['BaseFixedMapping']
+    header_parser: t.Optional['BaseFixedMapping']
 
 
 _SWAGGER_FUNCS: t.Dict[str, t.Dict[t.Optional[str], _SwaggerFunc]] = {}
@@ -42,11 +39,23 @@ _NameT = t.Union[  # pylint: disable=invalid-name
     ]]
 
 
+def _get_headers(wanted: list[str]) -> dict[str, str]:
+    import flask  # pylint: disable=import-outside-toplevel
+    headers = flask.request.headers
+    result = {}
+    for key in wanted:
+        try:
+            result[key] = headers[key]
+        except KeyError:
+            pass
+    return result
+
+
 def swaggerize(
     operation_name: _NameT,
     *,
     no_data: bool = False,
-) -> t.Callable[[_CallableT], _CallableT]:
+) -> t.Callable[[t.Callable[_P, _T]], t.Callable[_P, _T]]:
     """Mark this function as a function that should be included in the open api
     docs.
 
@@ -57,15 +66,25 @@ def swaggerize(
         don't the function should contain a call to ``from_flask`` as the first
         statement of the function.
     """
-    def __wrapper(func: _CallableT) -> _CallableT:
+    def __wrapper(func: t.Callable[_P, _T]) -> t.Callable[_P, _T]:
         if func.__name__ in _SWAGGER_FUNCS:  # pragma: no cover
             raise AssertionError(
-                'The function {} was already registered.'.format(
-                    func.__name__
-                )
+                f'The function {func.__name__} was already registered.'
             )
-        wrapped_func = process_query_params(func)
-        query_parser = wrapped_func.__cg_query_parser__  # type: ignore
+
+        import flask  # pylint: disable=import-outside-toplevel
+        wrapped_func, query_parser = _process_params(
+            func,
+            'Query',
+            lambda _: flask.request.args,
+            prefix_to_add='',
+        )
+        wrapped_func, header_parser = _process_params(
+            wrapped_func,
+            'Header',
+            _get_headers,
+            prefix_to_add='cg_',
+        )
 
         func_dict = _SWAGGER_FUNCS.setdefault(func.__name__, {})
         if isinstance(operation_name, str):
@@ -73,7 +92,8 @@ def swaggerize(
                 operation_name=operation_name,
                 no_data=no_data,
                 func=func,
-                query_parser=query_parser
+                query_parser=query_parser,
+                header_parser=header_parser,
             )
         else:
             for method, name in operation_name.items():
@@ -81,7 +101,8 @@ def swaggerize(
                     operation_name=name,
                     no_data=no_data,
                     func=func,
-                    query_parser=query_parser
+                    query_parser=query_parser,
+                    header_parser=header_parser,
                 )
 
         return wrapped_func
@@ -89,47 +110,52 @@ def swaggerize(
     return __wrapper
 
 
-def process_query_params(func: _CallableT) -> _CallableT:
+def _process_params(
+    func: t.Callable[_P, _T],
+    what: str,
+    get_params: t.Callable[[list[str]], object],
+    prefix_to_add: str,
+) -> tuple[t.Callable[_P, _T], None | BaseFixedMapping[t.Any]]:
     """Process query parameters of the given function.
 
     All parameters prefixed with ``query_`` are retrieved and parsed from the
     query parameters.
     """
+    prefix = f'{what.lower()}_'
+    prefix_len = len(prefix)
+    parameters = [
+        value for value in inspect.signature(func).parameters.values()
+        if value.name.startswith(prefix)
+    ]
+    if not parameters:
+        return func, None
+    wanted_keys = [
+        f'{prefix_to_add}{value.name[prefix_len:]}' for value in parameters
+    ]
     query_params = [
         inspect.Parameter(
-            name=value.name[len('query_'):],
+            name=f'{prefix_to_add}{value.name[prefix_len:]}',
             kind=value.kind,
             default=value.default,
             annotation=value.annotation,
-        ) for value in inspect.signature(func).parameters.values()
-        if value.name.startswith('query_')
+        ) for value in parameters
     ]
-    if not query_params:
-        query_parser = None
-    else:
-        query_parser = BaseFixedMapping.from_function_parameters_list(
-            query_params,
-            from_query=True,
-        )
-
-    func.__cg_query_parser__ = query_parser  # type: ignore
-    if query_parser is None:
-        return func
 
-    # We need flask in ``__inner``, but importing it here is faster
-
-    import flask  # pylint: disable=import-outside-toplevel
+    query_parser = BaseFixedMapping.from_function_parameters_list(
+        query_params,
+        from_query=True,
+    )
 
-    # Mypy know that this is never ``None`` so we can use it without check.
-    _parser = query_parser
+    log_msg = f'{what} parameters processed'
 
     @functools.wraps(func)
-    def __inner(*args: t.Any, **kwargs: t.Any) -> t.Any:
-        for key, value in _parser.try_parse_and_log(
-            flask.request.args,
-            msg='Query parameters processed',
+    def __inner(*args: _P.args, **kwargs: _P.kwargs) -> _T:
+        data = get_params(wanted_keys)
+        for key, value in query_parser.try_parse_and_log(
+            data,
+            msg=log_msg,
         ).items():
-            kwargs[f'query_{key}'] = value
+            kwargs[f'{prefix}{key[len(prefix_to_add):]}'] = value
         return func(*args, **kwargs)
 
-    return t.cast(_CallableT, __inner)
+    return __inner, query_parser

{codegrade-16.1.61 → codegrade-16.1.63}/codegrade/__init__.py

@@ -7,7 +7,7 @@ from functools import wraps
 from .client import AuthenticatedClient, Client
 
 __all__ = ("login", "AuthenticatedClient", "Client", "login_from_cli")
-__version__ = "16.1.61"
+__version__ = "16.1.63"
 
 
 @wraps(AuthenticatedClient.get)

{codegrade-16.1.61 → codegrade-16.1.63}/codegrade/_api/course.py

@@ -1646,7 +1646,8 @@ class CourseService(t.Generic[_ClientT]):
         course.
 
         This will return the permission as if you have already paid, even if
-        this is not the case.
+        this is not the case. We will also not check any restrictions of the
+        current session.
 
         :param course_id: The id of the course of which the permissions should
             be retrieved.

{codegrade-16.1.61 → codegrade-16.1.63}/codegrade/_api/file.py

@@ -14,6 +14,8 @@ from .. import parsers, utils
 if t.TYPE_CHECKING or os.getenv("CG_EAGERIMPORT", False):
     import codegrade
 
+    from ..models.mirror_file_result import MirrorFileResult
+
 
 _ClientT = t.TypeVar("_ClientT", bound="codegrade.client._BaseClient")
 
@@ -85,3 +87,57 @@ class FileService(t.Generic[_ClientT]):
                 ),
             ),
         )
+
+    def upload(
+        self: "FileService[codegrade.client.AuthenticatedClient]",
+        *,
+        max_age: Maybe["int"] = Nothing,
+        filename: "str" = "uploaded_file",
+        extra_parameters: t.Optional[
+            t.Mapping[str, t.Union[str, bool, int, float]]
+        ] = None,
+    ) -> "MirrorFileResult":
+        """Temporarily store some data on the server.
+
+        :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 extra_parameters: The extra query parameters you might want to
+            add. By default no extra query parameters are added.
+
+        :returns: The data for the file you can download on our server.
+        """
+
+        url = "/api/v1/files/"
+        params: t.Dict[str, t.Any] = {
+            **(extra_parameters or {}),
+            "filename": utils.to_dict(filename),
+        }
+        maybe_from_nullable(t.cast(t.Any, max_age)).if_just(
+            lambda val: params.__setitem__("max_age", val)
+        )
+
+        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, 200):
+            # fmt: off
+            from ..models.mirror_file_result import MirrorFileResult
+
+            # fmt: on
+            return parsers.JsonResponseParser(
+                parsers.ParserFor.make(MirrorFileResult)
+            ).try_parse(resp)
+
+        from ..models.any_error import AnyError
+
+        raise utils.get_error(
+            resp,
+            (
+                (
+                    (400, 409, 401, 403, 404, 429, 500),
+                    utils.unpack_union(AnyError),
+                ),
+            ),
+        )

{codegrade-16.1.61 → codegrade-16.1.63}/codegrade/_api/oauth_provider.py

@@ -7,6 +7,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 parsers, utils
 
@@ -168,3 +169,74 @@ class OAuthProviderService(t.Generic[_ClientT]):
                 ),
             ),
         )
+
+    def callback(
+        self,
+        *,
+        provider_id: "str",
+        state: Maybe["str"] = Nothing,
+        code: Maybe["str"] = Nothing,
+        error: Maybe["str"] = Nothing,
+        error_description: Maybe["str"] = Nothing,
+        extra_parameters: t.Optional[
+            t.Mapping[str, t.Union[str, bool, int, float]]
+        ] = None,
+    ) -> "bytes":
+        """The method that is used by OAuth providers after they completed the
+        login flow.
+
+        For the precise meaning of the query parameters see RFC 6749.
+
+        :param provider_id: The id of the OAuthProvider that completed the
+            flow.
+        :param state: The state.
+        :param code: The code.
+        :param error: The error.
+        :param error_description: The description of the error.
+        :param extra_parameters: The extra query parameters you might want to
+            add. By default no extra query parameters are added.
+
+        :returns: A response that is not in any defined format.
+        """
+
+        url = "/api/v1/oauth_providers/{providerId}/callback".format(
+            providerId=provider_id
+        )
+        params: t.Dict[str, t.Any] = {
+            **(extra_parameters or {}),
+        }
+        maybe_from_nullable(t.cast(t.Any, state)).if_just(
+            lambda val: params.__setitem__("state", val)
+        )
+        maybe_from_nullable(t.cast(t.Any, code)).if_just(
+            lambda val: params.__setitem__("code", val)
+        )
+        maybe_from_nullable(t.cast(t.Any, error)).if_just(
+            lambda val: params.__setitem__("error", val)
+        )
+        maybe_from_nullable(t.cast(t.Any, error_description)).if_just(
+            lambda val: params.__setitem__("error_description", val)
+        )
+
+        with self.__client as client:
+            resp = client.http.get(url=url, params=params)
+        utils.log_warnings(resp)
+
+        if utils.response_code_matches(resp.status_code, 200):
+            # fmt: off
+            # fmt: on
+            return parsers.ResponsePropertyParser("content", bytes).try_parse(
+                resp
+            )
+
+        from ..models.any_error import AnyError
+
+        raise utils.get_error(
+            resp,
+            (
+                (
+                    (400, 409, 401, 403, 404, 429, 500),
+                    utils.unpack_union(AnyError),
+                ),
+            ),
+        )

{codegrade-16.1.61 → codegrade-16.1.63}/codegrade/_api/permission.py

@@ -39,7 +39,8 @@ class PermissionService(t.Generic[_ClientT]):
 
         :param type: The type of permissions to get. This can be `global` or
             `course`. If `course` is passed this will return the permissions as
-            if you have already paid, even if this is not the case.
+            if you have already paid, even if this is not the case. It will
+            also not take any restrictions of this session into consideration.
         :param extra_parameters: The extra query parameters you might want to
             add. By default no extra query parameters are added.
 

{codegrade-16.1.61 → codegrade-16.1.63}/codegrade/_api/user.py

@@ -26,8 +26,10 @@ if t.TYPE_CHECKING or os.getenv("CG_EAGERIMPORT", False):
     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
+    from ..models.user_login_response import UserLoginResponse
 
 
 _ClientT = t.TypeVar("_ClientT", bound="codegrade.client._BaseClient")
@@ -364,6 +366,56 @@ class UserService(t.Generic[_ClientT]):
             ),
         )
 
+    def restrict(
+        self: "UserService[codegrade.client.AuthenticatedClient]",
+        json_body: t.Union[dict, list, "SessionRestrictionData"],
+        *,
+        extra_parameters: t.Optional[
+            t.Mapping[str, t.Union[str, bool, int, float]]
+        ] = None,
+    ) -> "UserLoginResponse":
+        """Revoke a given token.
+
+        :param json_body: The body of the request. See
+            :class:`.SessionRestrictionData` for information about the possible
+            fields. You can provide this data as a
+            :class:`.SessionRestrictionData` or as a dictionary.
+        :param extra_parameters: The extra query parameters you might want to
+            add. By default no extra query parameters are added.
+
+        :returns: An new token that has the given restrictions added.
+        """
+
+        url = "/api/v1/token/restrict"
+        params = extra_parameters or {}
+
+        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):
+            # fmt: off
+            from ..models.user_login_response import UserLoginResponse
+
+            # fmt: on
+            return parsers.JsonResponseParser(
+                parsers.ParserFor.make(UserLoginResponse)
+            ).try_parse(resp)
+
+        from ..models.any_error import AnyError
+
+        raise utils.get_error(
+            resp,
+            (
+                (
+                    (400, 409, 401, 403, 404, 429, 500),
+                    utils.unpack_union(AnyError),
+                ),
+            ),
+        )
+
     def logout(
         self,
         multipart_data: t.Union[dict, list, "LogoutUserData"],

{codegrade-16.1.61 → codegrade-16.1.63}/codegrade/client.py

@@ -538,7 +538,7 @@ class Client(_BaseClient):
         return httpx.Client(
             base_url=self.base_url,
             headers={
-                "User-Agent": "CodeGradeAPI/16.1.61",
+                "User-Agent": "CodeGradeAPI/16.1.63",
             },
             follow_redirects=True,
         )
@@ -558,7 +558,7 @@ class AuthenticatedClient(_BaseClient):
             base_url=self.base_url,
             headers={
                 "Authorization": f"Bearer {self.token}",
-                "User-Agent": "CodeGradeAPI/16.1.61",
+                "User-Agent": "CodeGradeAPI/16.1.63",
             },
             follow_redirects=True,
         )

{codegrade-16.1.61 → codegrade-16.1.63}/codegrade/models/__init__.py

@@ -174,6 +174,9 @@ from .clone_result import CloneResult
 from .code_editor_output_viewer_title_setting import (
     CodeEditorOutputViewerTitleSetting,
 )
+from .code_editor_start_on_assignment_description_setting import (
+    CodeEditorStartOnAssignmentDescriptionSetting,
+)
 from .code_quality_as_json import CodeQualityAsJSON
 from .code_quality_base_data import CodeQualityBaseData
 from .code_quality_data import CodeQualityData
@@ -595,6 +598,7 @@ from .register_user_data import RegisterUserData
 from .register_user_with_link_course_data import RegisterUserWithLinkCourseData
 from .release_info import ReleaseInfo
 from .release_message_max_time_setting import ReleaseMessageMaxTimeSetting
+from .removed_permissions import RemovedPermissions
 from .rename_group_group_data import RenameGroupGroupData
 from .render_html_enabled_setting import RenderHtmlEnabledSetting
 from .repository_connection_limit_reached_exception import (
@@ -642,7 +646,8 @@ from .server_time_correction_enabled_setting import (
 )
 from .server_time_diff_tolerance_setting import ServerTimeDiffToleranceSetting
 from .server_time_sync_interval_setting import ServerTimeSyncIntervalSetting
-from .session_restrictions import SessionRestrictions
+from .session_restriction_context import SessionRestrictionContext
+from .session_restriction_data import SessionRestrictionData
 from .setting_token_time_setting import SettingTokenTimeSetting
 from .setup_oauth_result import SetupOAuthResult
 from .simple_submission_mode_enabled_setting import (
@@ -670,6 +675,7 @@ from .start_payment_course_price_redirect_data import (
 )
 from .started_transaction import StartedTransaction
 from .student_payment_enabled_setting import StudentPaymentEnabledSetting
+from .student_view_enabled_setting import StudentViewEnabledSetting
 from .submission_validator_input_data import SubmissionValidatorInputData
 from .submissions_per_page_enabled_setting import (
     SubmissionsPerPageEnabledSetting,

{codegrade-16.1.61 → codegrade-16.1.63}/codegrade/models/all_site_settings.py

@@ -992,6 +992,14 @@ class AllSiteSettings(FrontendSiteSettings):
             res["RETRY_GROUP_SUBMISSION_GRADE_PASSBACK_ENABLED"] = to_dict(
                 self.retry_group_submission_grade_passback_enabled.value
             )
+        if self.student_view_enabled.is_just:
+            res["STUDENT_VIEW_ENABLED"] = to_dict(
+                self.student_view_enabled.value
+            )
+        if self.code_editor_start_on_assignment_description.is_just:
+            res["CODE_EDITOR_START_ON_ASSIGNMENT_DESCRIPTION"] = to_dict(
+                self.code_editor_start_on_assignment_description.value
+            )
         if self.auto_test_heartbeat_interval.is_just:
             res["AUTO_TEST_HEARTBEAT_INTERVAL"] = to_dict(
                 self.auto_test_heartbeat_interval.value
@@ -1247,6 +1255,8 @@ class AllSiteSettings(FrontendSiteSettings):
             analytics_enabled=parsed.ANALYTICS_ENABLED,
             hide_no_deadline_enabled=parsed.HIDE_NO_DEADLINE_ENABLED,
             retry_group_submission_grade_passback_enabled=parsed.RETRY_GROUP_SUBMISSION_GRADE_PASSBACK_ENABLED,
+            student_view_enabled=parsed.STUDENT_VIEW_ENABLED,
+            code_editor_start_on_assignment_description=parsed.CODE_EDITOR_START_ON_ASSIGNMENT_DESCRIPTION,
             auto_test_heartbeat_interval=parsed.AUTO_TEST_HEARTBEAT_INTERVAL,
             auto_test_heartbeat_max_missed=parsed.AUTO_TEST_HEARTBEAT_MAX_MISSED,
             auto_test_max_jobs_per_runner=parsed.AUTO_TEST_MAX_JOBS_PER_RUNNER,

codegrade-16.1.63/codegrade/models/code_editor_start_on_assignment_description_setting.py

@@ -0,0 +1,57 @@
+"""The module that defines the ``CodeEditorStartOnAssignmentDescriptionSetting`` model.
+
+SPDX-License-Identifier: AGPL-3.0-only OR BSD-3-Clause-Clear
+"""
+
+import typing as t
+from dataclasses import dataclass, field
+
+import cg_request_args as rqa
+
+from ..utils import to_dict
+
+
+@dataclass
+class CodeEditorStartOnAssignmentDescriptionSetting:
+    """ """
+
+    name: "t.Literal['CODE_EDITOR_START_ON_ASSIGNMENT_DESCRIPTION']"
+    value: "t.Optional[bool]"
+
+    raw_data: t.Optional[t.Dict[str, t.Any]] = field(init=False, repr=False)
+
+    data_parser: t.ClassVar = rqa.Lazy(
+        lambda: rqa.FixedMapping(
+            rqa.RequiredArgument(
+                "name",
+                rqa.StringEnum("CODE_EDITOR_START_ON_ASSIGNMENT_DESCRIPTION"),
+                doc="",
+            ),
+            rqa.RequiredArgument(
+                "value",
+                rqa.Nullable(rqa.SimpleValue.bool),
+                doc="",
+            ),
+        ).use_readable_describe(True)
+    )
+
+    def to_dict(self) -> t.Dict[str, t.Any]:
+        res: t.Dict[str, t.Any] = {
+            "name": to_dict(self.name),
+            "value": to_dict(self.value),
+        }
+        return res
+
+    @classmethod
+    def from_dict(
+        cls: t.Type["CodeEditorStartOnAssignmentDescriptionSetting"],
+        d: t.Dict[str, t.Any],
+    ) -> "CodeEditorStartOnAssignmentDescriptionSetting":
+        parsed = cls.data_parser.try_parse(d)
+
+        res = cls(
+            name=parsed.name,
+            value=parsed.value,
+        )
+        res.raw_data = d
+        return res