codegrade 17.0.51__tar.gz → 17.0.53__tar.gz

{codegrade-17.0.51 → codegrade-17.0.53}/PKG-INFO

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

@@ -39,7 +39,7 @@ author = "CodeGrade Team"
 # built documents.
 #
 # The short X.Y version.
-version = "17.0.51"
+version = "17.0.53"
 # 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.51"
+html_title = "CodeGrade 17.0.53"
 
 # -- Extension configuration -------------------------------------------------
 

codegrade-17.0.51/docs/models/EntryTicketEnterData.rst → codegrade-17.0.53/docs/models/EnterRestrictionData.rst

@@ -1,9 +1,9 @@
-EntryTicketEnterData
+EnterRestrictionData
 ====================
 
-.. currentmodule:: codegrade.models.entry_ticket_enter_data
+.. currentmodule:: codegrade.models.enter_restriction_data
 
-.. autoclass:: EntryTicketEnterData
+.. autoclass:: EnterRestrictionData
    :members: entry_ticket
    :inherited-members:
    :exclude-members: raw_data, data_parser, to_dict, from_dict, __init__, __new__

{codegrade-17.0.51 → codegrade-17.0.53}/docs/models/FrontendSiteSettings.rst

@@ -4,6 +4,6 @@ FrontendSiteSettings
 .. currentmodule:: codegrade.models.frontend_site_settings
 
 .. autoclass:: FrontendSiteSettings
-   :members: assignment_max_points_enabled, download_editor_files_enabled, grading_notifications_enabled, hide_no_deadline_enabled, show_premium_badges, inline_rubric_viewer_enabled, register_enabled, assignment_default_grading_scale, assignment_default_grading_scale_points, assignment_percentage_decimals, assignment_point_decimals, assistant_models, code_editor_start_on_assignment_description, default_submission_page_tab, hide_code_editor_output_viewer_with_only_quiz_steps, hide_code_editor_filetree_controls_with_only_quiz_steps, new_auto_test_ubuntu_20_04_base_image_ids, new_auto_test_ubuntu_24_04_base_image_ids, quiz_minimum_questions_for_dropdown, simple_submission_navigate_to_latest_editor_session, access_token_modal_warning_time, access_token_toast_warning_time, login_token_before_time, student_payment_main_option, lti_lock_date_copying_enabled, blackboard_zip_upload_enabled, is_pearson, auto_generate_test_submission_enabled, code_editor_redesign_2026, entry_ticket_flow_enabled, tier_free_ai_enabled, tier_free_lti_enabled, tier_free_atv1_enabled, tier_free_jupyter_enabled, tier_free_quiz_enabled, tier_free_extended_runtime_enabled, tier_free_unlimited_install_steps_enabled, tier_free_max_students, tier_free_max_staff, tier_starter_ai_enabled, tier_starter_lti_enabled, tier_starter_atv1_enabled, tier_starter_jupyter_enabled, tier_starter_quiz_enabled, tier_starter_extended_runtime_enabled, tier_starter_unlimited_install_steps_enabled, tier_starter_max_students, tier_starter_max_staff, tier_advanced_ai_enabled, tier_advanced_lti_enabled, tier_advanced_atv1_enabled, tier_advanced_jupyter_enabled, tier_advanced_quiz_enabled, tier_advanced_extended_runtime_enabled, tier_advanced_unlimited_install_steps_enabled, tier_advanced_max_students, tier_advanced_max_staff
+   :members: assignment_max_points_enabled, download_editor_files_enabled, grading_notifications_enabled, hide_no_deadline_enabled, show_premium_badges, inline_rubric_viewer_enabled, register_enabled, assignment_default_grading_scale, assignment_default_grading_scale_points, assignment_percentage_decimals, assignment_point_decimals, assistant_models, code_editor_start_on_assignment_description, default_submission_page_tab, hide_code_editor_output_viewer_with_only_quiz_steps, hide_code_editor_filetree_controls_with_only_quiz_steps, new_auto_test_ubuntu_20_04_base_image_ids, new_auto_test_ubuntu_24_04_base_image_ids, quiz_minimum_questions_for_dropdown, simple_submission_navigate_to_latest_editor_session, access_token_modal_warning_time, access_token_toast_warning_time, login_token_before_time, student_payment_main_option, lti_lock_date_copying_enabled, blackboard_zip_upload_enabled, is_pearson, auto_generate_test_submission_enabled, code_editor_redesign_2026, tier_free_ai_enabled, tier_free_lti_enabled, tier_free_atv1_enabled, tier_free_jupyter_enabled, tier_free_quiz_enabled, tier_free_extended_runtime_enabled, tier_free_unlimited_install_steps_enabled, tier_free_max_students, tier_free_max_staff, tier_starter_ai_enabled, tier_starter_lti_enabled, tier_starter_atv1_enabled, tier_starter_jupyter_enabled, tier_starter_quiz_enabled, tier_starter_extended_runtime_enabled, tier_starter_unlimited_install_steps_enabled, tier_starter_max_students, tier_starter_max_staff, tier_advanced_ai_enabled, tier_advanced_lti_enabled, tier_advanced_atv1_enabled, tier_advanced_jupyter_enabled, tier_advanced_quiz_enabled, tier_advanced_extended_runtime_enabled, tier_advanced_unlimited_install_steps_enabled, tier_advanced_max_students, tier_advanced_max_staff
    :inherited-members:
    :exclude-members: raw_data, data_parser, to_dict, from_dict, __init__, __new__

{codegrade-17.0.51 → codegrade-17.0.53}/docs/models/GlobalPermMap.rst

@@ -4,6 +4,6 @@ GlobalPermMap
 .. currentmodule:: codegrade.models.global_perm_map
 
 .. autoclass:: GlobalPermMap
-   :members: can_create_courses_in_all_tenants, can_edit_coupons, can_edit_pricing, can_impersonate_users, can_list_hidden_tenants, can_manage_all_community_library_items, can_manage_background_jobs, can_manage_git_connections_in_all_tenants, can_manage_global_roles, can_manage_lti_providers, can_manage_pearson_templates, can_manage_quarantined_registrations, can_manage_site_settings, can_manage_sso_providers, can_manage_tenants, can_manage_tenant_roles_in_all_tenants, can_search_users_in_all_tenants, can_see_all_transactions, can_see_coupons, can_see_statistics_in_all_tenants, can_skip_payment_in_all_tenants, is_global_admin
+   :members: can_create_courses_in_all_tenants, can_edit_coupons, can_edit_pricing, can_impersonate_users, can_list_hidden_tenants, can_manage_all_community_library_items, can_manage_background_jobs, can_manage_git_connections_in_all_tenants, can_manage_global_roles, can_manage_lti_providers, can_manage_pearson_templates, can_manage_quarantined_registrations, can_manage_site_settings, can_manage_sso_providers, can_manage_tenant_roles_in_all_tenants, can_manage_tenants, can_search_users_in_all_tenants, can_see_all_transactions, can_see_coupons, can_see_statistics_in_all_tenants, can_skip_payment_in_all_tenants, is_global_admin
    :inherited-members:
    :exclude-members: raw_data, data_parser, to_dict, from_dict, __init__, __new__

{codegrade-17.0.51 → codegrade-17.0.53}/pyproject.toml

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

{codegrade-17.0.51 → codegrade-17.0.53}/src/cg_request_args/__init__.py

@@ -13,6 +13,7 @@ from ._convert import (
 from ._convert import (
     as_converter as as_converter,
 )
+from ._default import Default as Default
 from ._doc import Doc as Doc
 from ._enum import EnumValue as EnumValue
 from ._enum import SingleEnumValue as SingleEnumValue
@@ -63,6 +64,7 @@ from ._octet_stream import (
 )
 from ._parse_utils import Transform as Transform
 from ._query import QueryParam as QueryParam
+from ._rich_value import Password as Password
 from ._rich_value import RichValue as RichValue
 from ._set import Set as Set
 from ._swagger_utils import OpenAPISchema as OpenAPISchema

{codegrade-17.0.51 → codegrade-17.0.53}/src/cg_request_args/_any_value.py

@@ -11,8 +11,8 @@ __all__ = ('AnyValue',)
 class _AnyValue(_Parser[_t.Any]):
     """A validator for an ``Any`` value. This will allow any value."""
 
-    @staticmethod
-    def describe() -> str:
+    @_t.override
+    def _describe(self) -> str:
         """The description for the any parser."""
         return 'Any'
 

{codegrade-17.0.51 → codegrade-17.0.53}/src/cg_request_args/_base.py

@@ -5,9 +5,13 @@ This file contains the base parser class, and simple classes that you can use
 to parse primitive types.
 """
 
+from __future__ import annotations
+
 import abc
+import contextvars
 import copy
 import typing as t
+from dataclasses import dataclass, field
 
 import structlog
 
@@ -20,7 +24,7 @@ from ._utils import T_COV as _T_COV
 from ._utils import Final, type_to_name
 from ._utils import T as _T
 from ._utils import Y as _Y
-from .exceptions import ParseError
+from .exceptions import ErrorNode, ParseError
 
 logger = structlog.get_logger()
 
@@ -33,6 +37,58 @@ LogReplacer = t.Callable[[str, object], object]
 
 _ParserT = t.TypeVar('_ParserT', bound='Parser')
 
+
+@dataclass(slots=True)
+class _DescribeCtx:
+    """Per-call state for :meth:`Parser.describe`, supplying cycle detection
+    for recursive parser graphs (typically built with :class:`.Lazy` referring
+    back to a containing parser).
+
+    Subclass authors never see this — they implement :meth:`Parser._describe`
+    and recurse via ``child.describe()`` as usual. The public
+    :meth:`Parser.describe` finds the active ``_DescribeCtx`` on a
+    :data:`ContextVar` (or creates one if none) and dispatches through
+    :meth:`visit`, which handles cycle detection and Common-Lisp-style
+    ``#N=...`` / ``#N#`` labelling.
+    """
+
+    in_progress: set[int] = field(default_factory=set)
+    labels: dict[int, int] = field(default_factory=dict)
+    referenced: set[int] = field(default_factory=set)
+    counter: int = 0
+
+    def visit(self, parser: Parser) -> str:
+        """Describe ``parser`` under this context.
+
+        If ``parser`` is currently being described (cycle), assign it a
+        label and return ``'#N#'``. Otherwise call its :meth:`_describe`
+        and, if a later back-reference observed a cycle anchored here,
+        wrap the body as ``'#N=body'``.
+        """
+        key = id(parser)
+        if key in self.in_progress:
+            label = self.labels.get(key)
+            if label is None:
+                label = self.counter
+                self.counter += 1
+                self.labels[key] = label
+            self.referenced.add(label)
+            return f'#{label}#'
+        self.in_progress.add(key)
+        try:
+            body = parser._describe()  # noqa: SLF001
+        finally:
+            self.in_progress.discard(key)
+        label = self.labels.get(key)
+        if label is not None and label in self.referenced:
+            return f'#{label}={body}'
+        return body
+
+
+_describe_ctx: contextvars.ContextVar[t.Optional[_DescribeCtx]] = (
+    contextvars.ContextVar('cg_request_args._describe_ctx', default=None)
+)
+
 __all__ = (
     'Parser',
     'Union',
@@ -124,9 +180,35 @@ class Parser(t.Generic[_T_COV]):
         """
         ...
 
-    @abc.abstractmethod
+    @t.final
     def describe(self) -> str:
-        """Describe this parser, used for error messages."""
+        """Describe this parser, used for error messages.
+
+        Subclasses must not override this; override :meth:`_describe` instead.
+        This method routes through a :class:`_DescribeCtx` (held on a
+        :data:`ContextVar`) so that recursive parser graphs are bounded by
+        the number of unique parsers rather than by the number of edges.
+        """
+        ctx = _describe_ctx.get()
+        if ctx is not None:
+            return ctx.visit(self)
+        ctx = _DescribeCtx()
+        token = _describe_ctx.set(ctx)
+        try:
+            return ctx.visit(self)
+        finally:
+            _describe_ctx.reset(token)
+
+    @abc.abstractmethod
+    def _describe(self) -> str:
+        """Produce this parser's describe body.
+
+        Recurse via ``child.describe()`` (the public method) — the active
+        :class:`_DescribeCtx` is found via :data:`_describe_ctx` and applies
+        cycle detection transparently. For super-chain composition (rare,
+        e.g. :class:`._Password`), call ``super()._describe()`` directly to
+        bypass the cycle-detection wrapper.
+        """
         ...
 
     @abc.abstractmethod
@@ -245,7 +327,7 @@ class Parser(t.Generic[_T_COV]):
                         ' type {}'
                     ).format(type(json))
                 },
-            )
+            ) from None
 
 
 class Union(t.Generic[_T, _Y], Parser[t.Union[_T, _Y]]):
@@ -296,7 +378,8 @@ class Union(t.Generic[_T, _Y], Parser[t.Union[_T, _Y]]):
                 lambda: _RichUnion(first, second)
             )
 
-    def describe(self) -> str:
+    @t.override
+    def _describe(self) -> str:
         return self._parser.describe()
 
     def _to_open_api(self, schema: _OpenAPISchema) -> t.Mapping[str, t.Any]:
@@ -317,7 +400,8 @@ class SimpleValueFactory(t.Generic[_SimpleValueT], Parser[_SimpleValueT]):
 
     __slots__ = ('typ',)
 
-    def describe(self) -> str:
+    @t.override
+    def _describe(self) -> str:
         return type_to_name(self.typ)
 
     def __init__(self, typ: t.Type[_SimpleValueT]) -> None:
@@ -345,7 +429,8 @@ class SimpleValueFactory(t.Generic[_SimpleValueT], Parser[_SimpleValueT]):
 class _NullValue(Parser[None]):
     __slots__ = ()
 
-    def describe(self) -> str:
+    @t.override
+    def _describe(self) -> str:
         return 'null'
 
     def _to_open_api(self, schema: _OpenAPISchema) -> t.Mapping[str, t.Any]:
@@ -379,8 +464,9 @@ class _SimpleUnion(t.Generic[_SimpleUnionT], Parser[_SimpleUnionT]):
         super().__init__()
         self.typs: Final[t.Tuple[t.Type[_SimpleUnionT], ...]] = typs
 
-    def describe(self) -> str:
-        return 'Union[{}]'.format(', '.join(map(type_to_name, self.typs)))
+    @t.override
+    def _describe(self) -> str:
+        return ' | '.join(map(type_to_name, self.typs))
 
     def _to_open_api(self, schema: _OpenAPISchema) -> t.Mapping[str, t.Any]:
         return {
@@ -417,32 +503,45 @@ class _SimpleUnion(t.Generic[_SimpleUnionT], Parser[_SimpleUnionT]):
         return self._raise(value)
 
 
-class _RichUnion(t.Generic[_T, _Y], Parser[t.Union[_T, _Y]]):
-    __slots__ = ('__first', '__second')
+class _RichUnion[T, Y](Parser[T | Y]):
+    __slots__ = ('_parsers',)
 
-    def __init__(self, first: Parser[_T], second: Parser[_Y]) -> None:
+    def __init__(self, first: Parser[T], second: Parser[Y]) -> None:
         super().__init__()
-        self.__first = first
-        self.__second = second
 
-    def describe(self) -> str:
-        first = self.__first.describe()
-        second = self.__second.describe()
-        return 'Union[{}, {}]'.format(first, second)
+        # Unwrap _RichUnion so that try_parse iterates a flat list of
+        # alternatives instead of recursing through a nested tree of
+        # unions — nesting otherwise costs one Python frame per arm at
+        # parse time, which can tip the interpreter past the recursion
+        # limit when cyclic GC fires concurrently and break out via
+        # sys.unraisablehook.
+        def get[Z](parser: Parser[Z]) -> t.Sequence[Parser[Z]]:
+            match parser:
+                case _RichUnion(_parsers=sub_parsers):
+                    return sub_parsers
+                case _:
+                    return [parser]
+
+        self._parsers: tuple[Parser[T] | Parser[Y], ...] = (
+            *get(first),
+            *get(second),
+        )
+        assert len(self._parsers) > 0, 'Must have at least one parser'
+
+    @t.override
+    def _describe(self) -> str:
+        return ' | '.join(parser.describe() for parser in self._parsers)
 
     def _to_open_api(self, schema: _OpenAPISchema) -> t.Mapping[str, t.Any]:
         return {
-            'anyOf': [
-                self.__first.to_open_api(schema),
-                self.__second.to_open_api(schema),
-            ]
+            'anyOf': [parser.to_open_api(schema) for parser in self._parsers]
         }
 
-    def try_parse(self, value: object) -> t.Union[_T, _Y]:
-        try:
-            return self.__first.try_parse(value)
-        except ParseError as first_err:
+    def try_parse(self, value: object) -> T | Y:
+        errs: list[ErrorNode] = []
+        for parser in self._parsers:
             try:
-                return self.__second.try_parse(value)
-            except ParseError as second_err:
-                raise ParseError.any_of([first_err.node, second_err.node])
+                return parser.try_parse(value)
+            except ParseError as err:
+                errs.append(err.node)
+        raise ParseError.any_of(errs)

{codegrade-17.0.51 → codegrade-17.0.53}/src/cg_request_args/_convert.py

@@ -17,6 +17,7 @@ from cg_dt_utils import DatetimeWithTimezone
 
 from ._any_value import AnyValue
 from ._base import Parser, SimpleValue
+from ._default import Default
 from ._doc import Doc
 from ._enum import EnumValue, SingleEnumValue, StringEnum, StringLiteralAsEnum
 from ._lazy import Lazy
@@ -24,6 +25,7 @@ from ._list import List, TwoTuple
 from ._literal import LiteralBoolean
 from ._mapping import (
     BaseFixedMapping,
+    DefaultArgument,
     DiscriminatedUnion,
     LookupMapping,
     OptionalArgument,
@@ -31,7 +33,7 @@ from ._mapping import (
 )
 from ._nullable import Nullable
 from ._query import QueryParam
-from ._rich_value import RichValue
+from ._rich_value import Password, RichValue
 from ._set import Set
 from ._utils import Annotated, Literal, is_typeddict
 
@@ -243,20 +245,68 @@ def get_required_keys(typ: object) -> t.Set[str]:
     return required_keys
 
 
+def _peek_default(subtyp: t.Any) -> t.Optional[Default[t.Any]]:
+    """Return the `Default(...)` marker on a TypedDict field, peeking past
+    `Required`/`NotRequired`. `None` if absent. Raises on duplicates.
+    """
+    inner = subtyp
+    if t.get_origin(inner) in (t.Required, t.NotRequired):
+        inner = t.get_args(inner)[0]
+    if t.get_origin(inner) is not Annotated:
+        return None
+    defaults = [
+        arg for arg in t.get_args(inner)[1:] if isinstance(arg, Default)
+    ]
+    if not defaults:
+        return None
+    if len(defaults) > 1:
+        raise AssertionError(
+            f'Field annotation {subtyp!r} has multiple Default(...) markers;'
+            ' only one is allowed per field.'
+        )
+    return defaults[0]
+
+
+_AnyArg = RequiredArgument | OptionalArgument | DefaultArgument
+
+
 def _get_args_typeddict(
     ctx: ConvertCtx,
     get_doc: t.Callable[[str], str] = lambda _: '',
-) -> t.Sequence[t.Union[RequiredArgument, OptionalArgument]]:
-    args: t.List[t.Union[RequiredArgument, OptionalArgument]] = []
+) -> t.Sequence[_AnyArg]:
+    args: t.List[_AnyArg] = []
     annotations = t.get_type_hints(ctx.typ, include_extras=True)
     required_keys = get_required_keys(ctx.typ)
 
     for key, subtyp in annotations.items():
         doc = get_doc(key)
-
+        default_marker = _peek_default(subtyp)
         sub_parse = ctx.recurse_with_guard(subtyp)
 
-        if key in required_keys:
+        if default_marker is not None:
+            if key not in required_keys:
+                raise AssertionError(
+                    f'TypedDict {getattr(ctx.typ, "__name__")} field {key!r}'
+                    ' combines NotRequired and Default; use one or the other.'
+                )
+            default_value = default_marker.value
+            # `_default=default_value` binds the value at lambda construction,
+            # whereas a `lambda: default_value` would late-bind to the loop
+            # variable, leaving every lambda to return the same final value.
+            # The cast is then needed because the lambda's `Callable[[Any],
+            # Any]` shape doesn't match `Callable[[], _T]`.
+            args.append(
+                DefaultArgument(  # type: ignore[misc]
+                    key,
+                    sub_parse,
+                    doc,
+                    default=t.cast(
+                        t.Callable,
+                        lambda _default=default_value: _default,
+                    ),
+                )
+            )
+        elif key in required_keys:
             args.append(
                 RequiredArgument(key, sub_parse, doc)  # type: ignore[misc]
             )
@@ -358,11 +408,13 @@ def _is_string_literal(typ: object) -> bool:
 
 @as_converter(
     lambda x: x.origin == Annotated
-    and any(isinstance(arg, Doc) for arg in t.get_args(x.typ)[1:]),
+    and any(isinstance(arg, (Doc, Default)) for arg in t.get_args(x.typ)[1:]),
     priority=ConvertPriority.default(),
 )
-def _convert_annotated_doc(ctx: ConvertCtx) -> Parser:
-    """Unwrap ``Annotated[T, Doc(...)]`` to ``T``, ignoring the doc metadata."""
+def _convert_annotated_type(ctx: ConvertCtx) -> Parser:
+    """Unwrap ``Annotated[T, Doc(...)]`` (or ``Default`` instead of ``Doc``) to
+    ``T``, ignoring the doc metadata.
+    """
     inner = t.get_args(ctx.typ)[0]
     return ctx.update_type(inner).convert()
 
@@ -435,6 +487,11 @@ def _convert_lookup_mapping(ctx: ConvertCtx) -> Parser:
         return LookupMapping(ctx.update_type(value).convert())
 
 
+@as_converter(lambda x: x.typ is Password, priority=ConvertPriority.high())
+def _convert_password(_: ConvertCtx) -> Parser:
+    return RichValue.Password
+
+
 @as_converter(lambda x: x.typ == uuid.UUID, priority=ConvertPriority.high())
 def _convert_uuid(_: ConvertCtx) -> Parser:
     return RichValue.UUID

codegrade-17.0.53/src/cg_request_args/_default.py

@@ -0,0 +1,22 @@
+"""Annotated metadata marker for TypedDict field defaults."""
+
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+_T = t.TypeVar('_T')
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class Default(t.Generic[_T]):
+    """Annotated metadata marker for a server-side default value.
+
+    Use with ``Annotated[T, Default(value)]`` on a TypedDict field to declare
+    that the field is optional on the wire but the parser fills in ``value``
+    when the field is absent. The field stays required at the TypedDict level
+    so callers can narrow on it, while existing clients that never sent it
+    keep parsing successfully.
+    """
+
+    value: _T

{codegrade-17.0.51 → codegrade-17.0.53}/src/cg_request_args/_enum.py

@@ -37,7 +37,8 @@ class StringEnum(t.Generic[_T], Parser[_T]):
         self.str_parser = str_parser
         self.__as_enum = as_enum
 
-    def describe(self) -> str:
+    @t.override
+    def _describe(self) -> str:
         return 'Enum[{}]'.format(', '.join(map(repr, sorted(self.opts))))
 
     def _to_open_api(self, schema: OpenAPISchema) -> t.Mapping[str, t.Any]:
@@ -74,7 +75,8 @@ class EnumValue(t.Generic[_EnumT], Parser[_EnumT]):
         super().__init__()
         self.__typ = typ
 
-    def describe(self) -> str:
+    @t.override
+    def _describe(self) -> str:
         return 'Enum[{}]'.format(
             ', '.join(repr(opt.name) for opt in self.__typ)
         )
@@ -96,8 +98,8 @@ class EnumValue(t.Generic[_EnumT], Parser[_EnumT]):
 
         try:
             return self.__typ[value]
-        except KeyError as err:
-            raise ParseError.leaf(self, value) from err
+        except KeyError:
+            raise ParseError.leaf(self, value) from None
 
 
 class SingleEnumValue(t.Generic[_EnumT], Parser[_EnumT]):
@@ -111,7 +113,8 @@ class SingleEnumValue(t.Generic[_EnumT], Parser[_EnumT]):
         self.opts = {val.name: val for val in values}
         self.str_parser = str_parser
 
-    def describe(self) -> str:
+    @t.override
+    def _describe(self) -> str:
         return 'Enum[{}]'.format(', '.join(map(repr, sorted(self.opts))))
 
     def _to_open_api(self, schema: OpenAPISchema) -> t.Mapping[str, t.Any]:
@@ -124,5 +127,5 @@ class SingleEnumValue(t.Generic[_EnumT], Parser[_EnumT]):
         str_val = self.str_parser.try_parse(value)
         try:
             return self.opts[str_val]
-        except KeyError as exc:
-            raise ParseError.leaf(self, value) from exc
+        except KeyError:
+            raise ParseError.leaf(self, value) from None

{codegrade-17.0.51 → codegrade-17.0.53}/src/cg_request_args/_lazy.py

@@ -45,7 +45,8 @@ class Lazy(t.Generic[_T], Parser[_T]):
                     self._make_parser = None
         return parser
 
-    def describe(self) -> str:
+    @t.override
+    def _describe(self) -> str:
         return self.parser.describe()
 
     def _to_open_api(self, schema: OpenAPISchema) -> t.Mapping[str, t.Any]:

{codegrade-17.0.51 → codegrade-17.0.53}/src/cg_request_args/_list.py

@@ -21,7 +21,8 @@ class List(t.Generic[_T], Parser[t.Sequence[_T]]):
         super().__init__()
         self.__el_type: Final = el_type
 
-    def describe(self) -> str:
+    @t.override
+    def _describe(self) -> str:
         return f'List[{self.__el_type.describe()}]'
 
     def _to_open_api(self, schema: OpenAPISchema) -> t.Mapping[str, t.Any]:
@@ -77,7 +78,8 @@ class ListSizeRestrictions(t.Generic[_T], Parser[t.Sequence[_T]]):
             assert self._max_size >= 1
             assert self._max_size > self._min_size
 
-    def describe(self) -> str:
+    @t.override
+    def _describe(self) -> str:
         base = self._parser.describe()
         if self._min_size > 0:
             base += f' of at least {self._min_size} items'
@@ -117,7 +119,8 @@ class TwoTuple(t.Generic[_T, _Y], Parser[t.Tuple[_T, _Y]]):
         self.__left = left
         self.__right = right
 
-    def describe(self) -> str:
+    @t.override
+    def _describe(self) -> str:
         return 'Tuple[{}, {}]'.format(
             self.__left.describe(), self.__right.describe()
         )

{codegrade-17.0.51 → codegrade-17.0.53}/src/cg_request_args/_literal.py

@@ -20,7 +20,8 @@ class LiteralBoolean(t.Generic[_BoolT], Parser[_BoolT]):
         super().__init__()
         self.__value = value
 
-    def describe(self) -> str:
+    @t.override
+    def _describe(self) -> str:
         return 'Literal[{}]'.format(self.__value)
 
     def _to_open_api(self, schema: OpenAPISchema) -> t.Mapping[str, t.Any]: