"""The module that defines the ``PatchAttestAssignmentData`` 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 cg_maybe import Maybe, Nothing
from cg_maybe.utils import maybe_from_nullable
from .. import parsers
from ..utils import to_dict
from .assignment_anonymization_algo import AssignmentAnonymizationAlgo
from .assignment_percentage_grading_settings import (
AssignmentPercentageGradingSettings,
)
from .assignment_points_grading_settings import AssignmentPointsGradingSettings
from .fixed_grade_availability import FixedGradeAvailability
from .submission_validator_input_data import SubmissionValidatorInputData
[docs]
@dataclass(kw_only=True)
class PatchAttestAssignmentData:
""" """
#: The type of the assignment this changes.
type: t.Literal["attest"]
#: The new name of the assignment
name: Maybe[str] = Nothing
#: The maximum possible grade for this assignment. You can reset this by
#: passing `null` as value
max_grade: Maybe[t.Optional[float]] = Nothing
#: The group set id for this assignment. Set to `null` to make this
#: assignment not a group assignment
group_set_id: Maybe[t.Optional[int]] = Nothing
#: The ignore file to use
ignore: Maybe[t.Union[SubmissionValidatorInputData, str]] = Nothing
#: The ignore version to use, defaults to "IgnoreFilterManager".
ignore_version: Maybe[
t.Literal[
"EmptySubmissionFilter",
"IgnoreFilterManager",
"SubmissionValidator",
]
] = Nothing
#: Should anonymized grading be enabled for this assignment.
anonymized_grading: Maybe[t.Optional[AssignmentAnonymizationAlgo]] = (
Nothing
)
#: Grading settings of this assignment.
grading: Maybe[
t.Union[
AssignmentPointsGradingSettings,
AssignmentPercentageGradingSettings,
]
] = Nothing
#: The grade availability of this assignment.
grade_availability: Maybe[FixedGradeAvailability] = Nothing
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(
"type",
rqa.StringEnum("attest"),
doc="The type of the assignment this changes.",
),
rqa.OptionalArgument(
"name",
rqa.SimpleValue.str,
doc="The new name of the assignment",
),
rqa.OptionalArgument(
"max_grade",
rqa.Nullable(rqa.SimpleValue.float),
doc="The maximum possible grade for this assignment. You can reset this by passing `null` as value",
),
rqa.OptionalArgument(
"group_set_id",
rqa.Nullable(rqa.SimpleValue.int),
doc="The group set id for this assignment. Set to `null` to make this assignment not a group assignment",
),
rqa.OptionalArgument(
"ignore",
parsers.make_union(
parsers.ParserFor.make(SubmissionValidatorInputData),
rqa.SimpleValue.str,
),
doc="The ignore file to use",
),
rqa.OptionalArgument(
"ignore_version",
rqa.StringEnum(
"EmptySubmissionFilter",
"IgnoreFilterManager",
"SubmissionValidator",
),
doc='The ignore version to use, defaults to "IgnoreFilterManager".',
),
rqa.OptionalArgument(
"anonymized_grading",
rqa.Nullable(rqa.EnumValue(AssignmentAnonymizationAlgo)),
doc="Should anonymized grading be enabled for this assignment.",
),
rqa.OptionalArgument(
"grading",
parsers.make_union(
parsers.ParserFor.make(AssignmentPointsGradingSettings),
parsers.ParserFor.make(
AssignmentPercentageGradingSettings
),
),
doc="Grading settings of this assignment.",
),
rqa.OptionalArgument(
"grade_availability",
parsers.ParserFor.make(FixedGradeAvailability),
doc="The grade availability of this assignment.",
),
)
)
def __post_init__(self) -> None:
getattr(super(), "__post_init__", lambda: None)()
self.name = maybe_from_nullable(self.name)
self.max_grade = maybe_from_nullable(self.max_grade)
self.group_set_id = maybe_from_nullable(self.group_set_id)
self.ignore = maybe_from_nullable(self.ignore)
self.ignore_version = maybe_from_nullable(self.ignore_version)
self.anonymized_grading = maybe_from_nullable(self.anonymized_grading)
self.grading = maybe_from_nullable(self.grading)
self.grade_availability = maybe_from_nullable(self.grade_availability)
def to_dict(self) -> t.Dict[str, t.Any]:
res: t.Dict[str, t.Any] = {
"type": to_dict(self.type),
}
if self.name.is_just:
res["name"] = to_dict(self.name.value)
if self.max_grade.is_just:
res["max_grade"] = to_dict(self.max_grade.value)
if self.group_set_id.is_just:
res["group_set_id"] = to_dict(self.group_set_id.value)
if self.ignore.is_just:
res["ignore"] = to_dict(self.ignore.value)
if self.ignore_version.is_just:
res["ignore_version"] = to_dict(self.ignore_version.value)
if self.anonymized_grading.is_just:
res["anonymized_grading"] = to_dict(self.anonymized_grading.value)
if self.grading.is_just:
res["grading"] = to_dict(self.grading.value)
if self.grade_availability.is_just:
res["grade_availability"] = to_dict(self.grade_availability.value)
return res
@classmethod
def from_dict(
cls: t.Type[PatchAttestAssignmentData], d: t.Dict[str, t.Any]
) -> PatchAttestAssignmentData:
parsed = cls.data_parser.try_parse(d)
res = cls(
type=parsed.type,
name=parsed.name,
max_grade=parsed.max_grade,
group_set_id=parsed.group_set_id,
ignore=parsed.ignore,
ignore_version=parsed.ignore_version,
anonymized_grading=parsed.anonymized_grading,
grading=parsed.grading,
grade_availability=parsed.grade_availability,
)
res.raw_data = d
return res