diff --git a/omegaup/api.py b/omegaup/api.py index a5ae8e2..21eb3c0 100644 --- a/omegaup/api.py +++ b/omegaup/api.py @@ -557,6 +557,63 @@ def __init__( self.teachingAssistant = _CoursesByTimeType(**teachingAssistant) +@dataclasses.dataclass +class _AiEditorialJobDetails: + """_AiEditorialJobDetails""" + created_at: datetime.datetime + error_message: Optional[str] + is_retriable: bool + job_id: str + md_en: Optional[str] + md_es: Optional[str] + md_pt: Optional[str] + problem_alias: str + status: str + validation_verdict: Optional[str] + + def __init__( + self, + *, + created_at: int, + is_retriable: bool, + job_id: str, + problem_alias: str, + status: str, + error_message: Optional[str] = None, + md_en: Optional[str] = None, + md_es: Optional[str] = None, + md_pt: Optional[str] = None, + validation_verdict: Optional[str] = None, + # Ignore any unknown arguments + **_kwargs: Any, + ): + self.created_at = datetime.datetime.fromtimestamp(created_at) + if error_message is not None: + self.error_message = error_message + else: + self.error_message = None + self.is_retriable = is_retriable + self.job_id = job_id + if md_en is not None: + self.md_en = md_en + else: + self.md_en = None + if md_es is not None: + self.md_es = md_es + else: + self.md_es = None + if md_pt is not None: + self.md_pt = md_pt + else: + self.md_pt = None + self.problem_alias = problem_alias + self.status = status + if validation_verdict is not None: + self.validation_verdict = validation_verdict + else: + self.validation_verdict = None + + @dataclasses.dataclass class _ApiToken: """_ApiToken""" @@ -1385,6 +1442,189 @@ def __init__( self.username = username +@dataclasses.dataclass +class _CDP: + """_CDP""" + casesStore: '_CDPCasesStore' + problemCodeContent: str + problemCodeExtension: str + problemMarkdown: str + problemName: str + problemSolutionMarkdown: str + + def __init__( + self, + *, + casesStore: Dict[str, Any], + problemCodeContent: str, + problemCodeExtension: str, + problemMarkdown: str, + problemName: str, + problemSolutionMarkdown: str, + # Ignore any unknown arguments + **_kwargs: Any, + ): + self.casesStore = _CDPCasesStore(**casesStore) + self.problemCodeContent = problemCodeContent + self.problemCodeExtension = problemCodeExtension + self.problemMarkdown = problemMarkdown + self.problemName = problemName + self.problemSolutionMarkdown = problemSolutionMarkdown + + +@dataclasses.dataclass +class _CDPCase: + """_CDPCase""" + autoPoints: bool + caseID: str + groupID: str + lines: Sequence['_CDPLine'] + name: str + output: str + points: int + + def __init__( + self, + *, + autoPoints: bool, + caseID: str, + groupID: str, + lines: Sequence[Dict[str, Any]], + name: str, + output: str, + points: int, + # Ignore any unknown arguments + **_kwargs: Any, + ): + self.autoPoints = autoPoints + self.caseID = caseID + self.groupID = groupID + self.lines = [_CDPLine(**v) for v in lines] + self.name = name + self.output = output + self.points = points + + +@dataclasses.dataclass +class _CDPCasesStore: + """_CDPCasesStore""" + groups: Sequence['_CDPGroup'] + hide: bool + layouts: Sequence[Dict[str, str]] + selected: '_CDPCasesStore_selected' + + def __init__( + self, + *, + groups: Sequence[Dict[str, Any]], + hide: bool, + layouts: Sequence[Dict[str, str]], + selected: Dict[str, Any], + # Ignore any unknown arguments + **_kwargs: Any, + ): + self.groups = [_CDPGroup(**v) for v in groups] + self.hide = hide + self.layouts = [{k: v for k, v in v.items()} for v in layouts] + self.selected = _CDPCasesStore_selected(**selected) + + +@dataclasses.dataclass +class _CDPCasesStore_selected: + """_CDPCasesStore_selected""" + caseID: Optional[str] + groupID: Optional[str] + + def __init__( + self, + *, + caseID: Optional[str] = None, + groupID: Optional[str] = None, + # Ignore any unknown arguments + **_kwargs: Any, + ): + if caseID is not None: + self.caseID = caseID + else: + self.caseID = None + if groupID is not None: + self.groupID = groupID + else: + self.groupID = None + + +@dataclasses.dataclass +class _CDPGroup: + """_CDPGroup""" + autoPoints: bool + cases: Sequence['_CDPCase'] + groupID: str + name: str + points: int + ungroupedCase: bool + + def __init__( + self, + *, + autoPoints: bool, + cases: Sequence[Dict[str, Any]], + groupID: str, + name: str, + points: int, + ungroupedCase: bool, + # Ignore any unknown arguments + **_kwargs: Any, + ): + self.autoPoints = autoPoints + self.cases = [_CDPCase(**v) for v in cases] + self.groupID = groupID + self.name = name + self.points = points + self.ungroupedCase = ungroupedCase + + +@dataclasses.dataclass +class _CDPLine: + """_CDPLine""" + caseID: str + data: '_CDPLine_data' + label: str + lineID: str + + def __init__( + self, + *, + caseID: str, + data: Dict[str, Any], + label: str, + lineID: str, + # Ignore any unknown arguments + **_kwargs: Any, + ): + self.caseID = caseID + self.data = _CDPLine_data(**data) + self.label = label + self.lineID = lineID + + +@dataclasses.dataclass +class _CDPLine_data: + """_CDPLine_data""" + kind: Union[str, str, str, str] + value: str + + def __init__( + self, + *, + kind: Union[str, str, str, str], + value: str, + # Ignore any unknown arguments + **_kwargs: Any, + ): + self.kind = kind + self.value = value + + @dataclasses.dataclass class _CachedExtraProfileDetails: """_CachedExtraProfileDetails""" @@ -1931,6 +2171,7 @@ class _CommonPayload: isReviewer: bool isUnder13User: bool lockDownImage: str + mentorCanChooseCoder: bool navbarSection: str nextRegisteredContestForUser: Optional['_ContestListItem'] omegaUpLockDown: bool @@ -1956,6 +2197,7 @@ def __init__( isReviewer: bool, isUnder13User: bool, lockDownImage: str, + mentorCanChooseCoder: bool, navbarSection: str, omegaUpLockDown: bool, profileProgress: float, @@ -1987,6 +2229,7 @@ def __init__( self.isReviewer = isReviewer self.isUnder13User = isUnder13User self.lockDownImage = lockDownImage + self.mentorCanChooseCoder = mentorCanChooseCoder self.navbarSection = navbarSection if nextRegisteredContestForUser is not None: self.nextRegisteredContestForUser = _ContestListItem( @@ -2200,6 +2443,7 @@ class _ContestAdminDetails: alias: str archived: bool available_languages: Dict[str, str] + canSetRecommended: bool contest_for_teams: bool default_show_all_contestants_in_scoreboard: bool description: str @@ -2218,6 +2462,7 @@ class _ContestAdminDetails: points_decay_factor: float problems: Optional[Sequence['_ProblemsetProblem']] problemset_id: int + recommended: Optional[bool] requests_user_information: str rerun_id: Optional[int] score_mode: str @@ -2240,6 +2485,7 @@ def __init__( alias: str, archived: bool, available_languages: Dict[str, str], + canSetRecommended: bool, contest_for_teams: bool, default_show_all_contestants_in_scoreboard: bool, description: str, @@ -2266,6 +2512,7 @@ def __init__( original_contest_alias: Optional[str] = None, original_problemset_id: Optional[int] = None, problems: Optional[Sequence[Dict[str, Any]]] = None, + recommended: Optional[bool] = None, rerun_id: Optional[int] = None, scoreboard_url: Optional[str] = None, scoreboard_url_admin: Optional[str] = None, @@ -2282,6 +2529,7 @@ def __init__( k: v for k, v in available_languages.items() } + self.canSetRecommended = canSetRecommended self.contest_for_teams = contest_for_teams self.default_show_all_contestants_in_scoreboard = default_show_all_contestants_in_scoreboard self.description = description @@ -2309,6 +2557,10 @@ def __init__( else: self.problems = None self.problemset_id = problemset_id + if recommended is not None: + self.recommended = recommended + else: + self.recommended = None self.requests_user_information = requests_user_information if rerun_id is not None: self.rerun_id = rerun_id @@ -2389,6 +2641,7 @@ class _ContestDetails: points_decay_factor: float problems: Sequence['_ProblemsetProblem'] problemset_id: int + recommended: bool requests_user_information: str rerun_id: Optional[int] score_mode: str @@ -2426,6 +2679,7 @@ def __init__( points_decay_factor: float, problems: Sequence[Dict[str, Any]], problemset_id: int, + recommended: bool, requests_user_information: str, score_mode: str, scoreboard: int, @@ -2472,6 +2726,7 @@ def __init__( self.points_decay_factor = points_decay_factor self.problems = [_ProblemsetProblem(**v) for v in problems] self.problemset_id = problemset_id + self.recommended = recommended self.requests_user_information = requests_user_information if rerun_id is not None: self.rerun_id = rerun_id @@ -2701,6 +2956,7 @@ class _ContestIntroPayload: privacyStatement: '_PrivacyStatement' requestsUserInformation: str shouldShowModalToLoginWithRegisteredIdentity: bool + userBasicInformation: '_UserBasicInformation' def __init__( self, @@ -2710,6 +2966,7 @@ def __init__( privacyStatement: Dict[str, Any], requestsUserInformation: str, shouldShowModalToLoginWithRegisteredIdentity: bool, + userBasicInformation: Dict[str, Any], # Ignore any unknown arguments **_kwargs: Any, ): @@ -2718,6 +2975,8 @@ def __init__( self.privacyStatement = _PrivacyStatement(**privacyStatement) self.requestsUserInformation = requestsUserInformation self.shouldShowModalToLoginWithRegisteredIdentity = shouldShowModalToLoginWithRegisteredIdentity + self.userBasicInformation = _UserBasicInformation( + **userBasicInformation) @dataclasses.dataclass @@ -2879,6 +3138,7 @@ class _ContestListv2Payload: """_ContestListv2Payload""" contests: '_ContestList' countContests: '_ContestListv2Payload_countContests' + pageSize: int query: Optional[str] def __init__( @@ -2886,6 +3146,7 @@ def __init__( *, contests: Dict[str, Any], countContests: Dict[str, Any], + pageSize: int, query: Optional[str] = None, # Ignore any unknown arguments **_kwargs: Any, @@ -2893,6 +3154,7 @@ def __init__( self.contests = _ContestList(**contests) self.countContests = _ContestListv2Payload_countContests( **countContests) + self.pageSize = pageSize if query is not None: self.query = query else: @@ -2923,6 +3185,7 @@ def __init__( @dataclasses.dataclass class _ContestNewPayload: """_ContestNewPayload""" + canSetRecommended: Optional[bool] hasVisitedSection: Optional[bool] languages: Dict[str, str] @@ -2930,10 +3193,15 @@ def __init__( self, *, languages: Dict[str, str], + canSetRecommended: Optional[bool] = None, hasVisitedSection: Optional[bool] = None, # Ignore any unknown arguments **_kwargs: Any, ): + if canSetRecommended is not None: + self.canSetRecommended = canSetRecommended + else: + self.canSetRecommended = None if hasVisitedSection is not None: self.hasVisitedSection = hasVisitedSection else: @@ -3821,6 +4089,7 @@ class _CourseDetails: show_scoreboard: bool start_time: datetime.datetime student_count: Optional[int] + teaching_assistant_enabled: bool unlimited_duration: bool def __init__( @@ -3841,6 +4110,7 @@ def __init__( requests_user_information: str, show_scoreboard: bool, start_time: int, + teaching_assistant_enabled: bool, unlimited_duration: bool, finish_time: Optional[int] = None, languages: Optional[Sequence[str]] = None, @@ -3895,6 +4165,7 @@ def __init__( self.student_count = student_count else: self.student_count = None + self.teaching_assistant_enabled = teaching_assistant_enabled self.unlimited_duration = unlimited_duration @@ -4516,6 +4787,7 @@ class _CurrentSession: is_admin: bool is_under_13_user: bool loginIdentity: Optional[_OmegaUp_DAO_VO_Identities] + mentor_can_choose_coder: bool user: Optional[_OmegaUp_DAO_VO_Users] user_verification_deadline: Optional[datetime.datetime] valid: bool @@ -4528,6 +4800,7 @@ def __init__( classname: str, is_admin: bool, is_under_13_user: bool, + mentor_can_choose_coder: bool, valid: bool, apiTokenId: Optional[int] = None, auth_token: Optional[str] = None, @@ -4571,6 +4844,7 @@ def __init__( self.loginIdentity = _OmegaUp_DAO_VO_Identities(**loginIdentity) else: self.loginIdentity = None + self.mentor_can_choose_coder = mentor_can_choose_coder if user is not None: self.user = _OmegaUp_DAO_VO_Users(**user) else: @@ -6296,6 +6570,42 @@ def __init__( self.passedUsers = passedUsers +@dataclasses.dataclass +class _OmegaUp_Controllers_AiEditorial__apiGenerate: + """_OmegaUp_Controllers_AiEditorial__apiGenerate""" + job_id: Optional[str] + + def __init__( + self, + *, + job_id: Optional[str] = None, + # Ignore any unknown arguments + **_kwargs: Any, + ): + if job_id is not None: + self.job_id = job_id + else: + self.job_id = None + + +@dataclasses.dataclass +class _OmegaUp_Controllers_AiEditorial__apiStatus: + """_OmegaUp_Controllers_AiEditorial__apiStatus""" + job: Optional['_AiEditorialJobDetails'] + + def __init__( + self, + *, + job: Optional[Dict[str, Any]] = None, + # Ignore any unknown arguments + **_kwargs: Any, + ): + if job is not None: + self.job = _AiEditorialJobDetails(**job) + else: + self.job = None + + @dataclasses.dataclass class _OmegaUp_Controllers_Authorization__apiProblem: """_OmegaUp_Controllers_Authorization__apiProblem""" @@ -7598,6 +7908,21 @@ def __init__( self.progress = [_StudentProgressInCourse(**v) for v in progress] +@dataclasses.dataclass +class _OmegaUp_Controllers_Course__apiToggleTeachingAssistant: + """_OmegaUp_Controllers_Course__apiToggleTeachingAssistant""" + teaching_assistant_enabled: bool + + def __init__( + self, + *, + teaching_assistant_enabled: bool, + # Ignore any unknown arguments + **_kwargs: Any, + ): + self.teaching_assistant_enabled = teaching_assistant_enabled + + @dataclasses.dataclass class _OmegaUp_Controllers_Grader__apiStatus: """_OmegaUp_Controllers_Grader__apiStatus""" @@ -7890,6 +8215,21 @@ def __init__( self.clarifications = [_Clarification(**v) for v in clarifications] +@dataclasses.dataclass +class _OmegaUp_Controllers_Problem__apiConvertZipToCdp: + """_OmegaUp_Controllers_Problem__apiConvertZipToCdp""" + cdp: '_CDP' + + def __init__( + self, + *, + cdp: Dict[str, Any], + # Ignore any unknown arguments + **_kwargs: Any, + ): + self.cdp = _CDP(**cdp) + + @dataclasses.dataclass class _OmegaUp_Controllers_Problem__apiList: """_OmegaUp_Controllers_Problem__apiList""" @@ -8794,6 +9134,38 @@ def __init__( self.username = username +@dataclasses.dataclass +class _OmegaUp_Controllers_Run__apiExecute: + """_OmegaUp_Controllers_Run__apiExecute""" + nextExecutionTimestamp: datetime.datetime + + def __init__( + self, + *, + nextExecutionTimestamp: int, + # Ignore any unknown arguments + **_kwargs: Any, + ): + self.nextExecutionTimestamp = datetime.datetime.fromtimestamp( + nextExecutionTimestamp) + + +@dataclasses.dataclass +class _OmegaUp_Controllers_Run__apiExecuteForIDE: + """_OmegaUp_Controllers_Run__apiExecuteForIDE""" + nextExecutionTimestamp: datetime.datetime + + def __init__( + self, + *, + nextExecutionTimestamp: int, + # Ignore any unknown arguments + **_kwargs: Any, + ): + self.nextExecutionTimestamp = datetime.datetime.fromtimestamp( + nextExecutionTimestamp) + + @dataclasses.dataclass class _OmegaUp_Controllers_Run__apiList: """_OmegaUp_Controllers_Run__apiList""" @@ -9439,16 +9811,63 @@ def __init__( @dataclasses.dataclass class _OmegaUp_Controllers_User__apiStats: """_OmegaUp_Controllers_User__apiStats""" - runs: Sequence['_UserProfileStats'] + heatmap: Sequence['_OmegaUp_Controllers_User__apiStats_heatmap_entry'] + runs: Sequence['_OmegaUp_Controllers_User__apiStats_runs_entry'] def __init__( self, *, + heatmap: Sequence[Dict[str, Any]], runs: Sequence[Dict[str, Any]], # Ignore any unknown arguments **_kwargs: Any, ): - self.runs = [_UserProfileStats(**v) for v in runs] + self.heatmap = [ + _OmegaUp_Controllers_User__apiStats_heatmap_entry(**v) + for v in heatmap + ] + self.runs = [ + _OmegaUp_Controllers_User__apiStats_runs_entry(**v) for v in runs + ] + + +@dataclasses.dataclass +class _OmegaUp_Controllers_User__apiStats_heatmap_entry: + """_OmegaUp_Controllers_User__apiStats_heatmap_entry""" + count: int + date: str + + def __init__( + self, + *, + count: int, + date: str, + # Ignore any unknown arguments + **_kwargs: Any, + ): + self.count = count + self.date = date + + +@dataclasses.dataclass +class _OmegaUp_Controllers_User__apiStats_runs_entry: + """_OmegaUp_Controllers_User__apiStats_runs_entry""" + date: str + runs: int + verdict: str + + def __init__( + self, + *, + date: str, + runs: int, + verdict: str, + # Ignore any unknown arguments + **_kwargs: Any, + ): + self.date = date + self.runs = runs + self.verdict = verdict @dataclasses.dataclass @@ -9721,6 +10140,7 @@ class _ProblemDetails: languages: Sequence[str] letter: Optional[str] limits: '_SettingLimits' + nextExecutionTimestamp: Optional[datetime.datetime] nextSubmissionTimestamp: Optional[datetime.datetime] nominationStatus: '_NominationStatus' order: str @@ -9773,6 +10193,7 @@ def __init__( admin: Optional[bool] = None, difficulty: Optional[float] = None, letter: Optional[str] = None, + nextExecutionTimestamp: Optional[int] = None, nextSubmissionTimestamp: Optional[int] = None, preferred_language: Optional[str] = None, problemsetter: Optional[Dict[str, Any]] = None, @@ -9805,6 +10226,11 @@ def __init__( else: self.letter = None self.limits = _SettingLimits(**limits) + if nextExecutionTimestamp is not None: + self.nextExecutionTimestamp = datetime.datetime.fromtimestamp( + nextExecutionTimestamp) + else: + self.nextExecutionTimestamp = None if nextSubmissionTimestamp is not None: self.nextSubmissionTimestamp = datetime.datetime.fromtimestamp( nextSubmissionTimestamp) @@ -9860,10 +10286,13 @@ class _ProblemDetailsPayload: problem: '_ProblemInfo' problemLevel: Optional[str] publicTags: Optional[Sequence[str]] + reviewedProblemLevel: Optional[str] + reviewedPublicTags: Optional[Sequence[str]] + reviewedQualitySeal: Optional[bool] runs: Optional[Sequence['_Run']] selectedPrivateTags: Optional[Sequence[str]] selectedPublicTags: Optional[Sequence[str]] - solutionStatus: Optional[str] + solutionStatus: str solvers: Sequence['_BestSolvers'] totalRuns: Optional[int] user: '_UserInfoForProblem' @@ -9874,6 +10303,7 @@ def __init__( allowedSolutionsToSee: int, histogram: Dict[str, Any], problem: Dict[str, Any], + solutionStatus: str, solvers: Sequence[Dict[str, Any]], user: Dict[str, Any], allRuns: Optional[Sequence[Dict[str, Any]]] = None, @@ -9884,10 +10314,12 @@ def __init__( nominationStatus: Optional[Dict[str, Any]] = None, problemLevel: Optional[str] = None, publicTags: Optional[Sequence[str]] = None, + reviewedProblemLevel: Optional[str] = None, + reviewedPublicTags: Optional[Sequence[str]] = None, + reviewedQualitySeal: Optional[bool] = None, runs: Optional[Sequence[Dict[str, Any]]] = None, selectedPrivateTags: Optional[Sequence[str]] = None, selectedPublicTags: Optional[Sequence[str]] = None, - solutionStatus: Optional[str] = None, totalRuns: Optional[int] = None, # Ignore any unknown arguments **_kwargs: Any, @@ -9927,6 +10359,18 @@ def __init__( self.publicTags = [v for v in publicTags] else: self.publicTags = None + if reviewedProblemLevel is not None: + self.reviewedProblemLevel = reviewedProblemLevel + else: + self.reviewedProblemLevel = None + if reviewedPublicTags is not None: + self.reviewedPublicTags = [v for v in reviewedPublicTags] + else: + self.reviewedPublicTags = None + if reviewedQualitySeal is not None: + self.reviewedQualitySeal = reviewedQualitySeal + else: + self.reviewedQualitySeal = None if runs is not None: self.runs = [_Run(**v) for v in runs] else: @@ -9939,10 +10383,7 @@ def __init__( self.selectedPublicTags = [v for v in selectedPublicTags] else: self.selectedPublicTags = None - if solutionStatus is not None: - self.solutionStatus = solutionStatus - else: - self.solutionStatus = None + self.solutionStatus = solutionStatus self.solvers = [_BestSolvers(**v) for v in solvers] if totalRuns is not None: self.totalRuns = totalRuns @@ -10253,6 +10694,7 @@ class _ProblemInfo: languages: Sequence[str] letter: Optional[str] limits: '_SettingLimits' + nextExecutionTimestamp: Optional[datetime.datetime] nextSubmissionTimestamp: Optional[datetime.datetime] points: float preferred_language: Optional[str] @@ -10284,6 +10726,7 @@ def __init__( title: str, visibility: int, letter: Optional[str] = None, + nextExecutionTimestamp: Optional[int] = None, nextSubmissionTimestamp: Optional[int] = None, preferred_language: Optional[str] = None, problemsetter: Optional[Dict[str, Any]] = None, @@ -10303,6 +10746,11 @@ def __init__( else: self.letter = None self.limits = _SettingLimits(**limits) + if nextExecutionTimestamp is not None: + self.nextExecutionTimestamp = datetime.datetime.fromtimestamp( + nextExecutionTimestamp) + else: + self.nextExecutionTimestamp = None if nextSubmissionTimestamp is not None: self.nextSubmissionTimestamp = datetime.datetime.fromtimestamp( nextSubmissionTimestamp) @@ -10590,6 +11038,39 @@ def __init__( self.tried = tried +@dataclasses.dataclass +class _ProblemRequestData: + """_ProblemRequestData""" + contestAlias: Optional[str] + preventProblemsetOpen: bool + problemAlias: str + problemsetId: Optional[int] + statementType: str + + def __init__( + self, + *, + preventProblemsetOpen: bool, + problemAlias: str, + statementType: str, + contestAlias: Optional[str] = None, + problemsetId: Optional[int] = None, + # Ignore any unknown arguments + **_kwargs: Any, + ): + if contestAlias is not None: + self.contestAlias = contestAlias + else: + self.contestAlias = None + self.preventProblemsetOpen = preventProblemsetOpen + self.problemAlias = problemAlias + if problemsetId is not None: + self.problemsetId = problemsetId + else: + self.problemsetId = None + self.statementType = statementType + + @dataclasses.dataclass class _ProblemSettings: """_ProblemSettings""" @@ -13615,19 +14096,49 @@ def __init__( @dataclasses.dataclass -class _UserDependent: - """_UserDependent""" - classname: str - name: Optional[str] - parent_email_verification_deadline: Optional[datetime.datetime] - parent_verified: Optional[bool] - username: str +class _UserBasicInformation: + """_UserBasicInformation""" + country: Optional[str] + school: Optional[int] + state: Optional[str] def __init__( self, *, - classname: str, - username: str, + country: Optional[str] = None, + school: Optional[int] = None, + state: Optional[str] = None, + # Ignore any unknown arguments + **_kwargs: Any, + ): + if country is not None: + self.country = country + else: + self.country = None + if school is not None: + self.school = school + else: + self.school = None + if state is not None: + self.state = state + else: + self.state = None + + +@dataclasses.dataclass +class _UserDependent: + """_UserDependent""" + classname: str + name: Optional[str] + parent_email_verification_deadline: Optional[datetime.datetime] + parent_verified: Optional[bool] + username: str + + def __init__( + self, + *, + classname: str, + username: str, name: Optional[str] = None, parent_email_verification_deadline: Optional[int] = None, parent_verified: Optional[bool] = None, @@ -13699,6 +14210,42 @@ def __init__( self.verified = verified +@dataclasses.dataclass +class _UserDocsPayload: + """_UserDocsPayload""" + docs: Dict[str, Sequence['_UserDocument']] + + def __init__( + self, + *, + docs: Dict[str, Sequence[Dict[str, Any]]], + # Ignore any unknown arguments + **_kwargs: Any, + ): + self.docs = { + k: [_UserDocument(**v) for v in v] + for k, v in docs.items() + } + + +@dataclasses.dataclass +class _UserDocument: + """_UserDocument""" + name: str + url: str + + def __init__( + self, + *, + name: str, + url: str, + # Ignore any unknown arguments + **_kwargs: Any, + ): + self.name = name + self.url = url + + @dataclasses.dataclass class _UserInfoForProblem: """_UserInfoForProblem""" @@ -14176,6 +14723,39 @@ def __init__( self.rank = rank +@dataclasses.dataclass +class _UserRankTableLoggedOutPayload: + """_UserRankTableLoggedOutPayload""" + isLogged: bool + lastUpdated: Optional[datetime.datetime] + length: int + page: int + pagerItems: Sequence['_PageItem'] + ranking: '_UserRank' + + def __init__( + self, + *, + isLogged: bool, + length: int, + page: int, + pagerItems: Sequence[Dict[str, Any]], + ranking: Dict[str, Any], + lastUpdated: Optional[int] = None, + # Ignore any unknown arguments + **_kwargs: Any, + ): + self.isLogged = isLogged + if lastUpdated is not None: + self.lastUpdated = datetime.datetime.fromtimestamp(lastUpdated) + else: + self.lastUpdated = None + self.length = length + self.page = page + self.pagerItems = [_PageItem(**v) for v in pagerItems] + self.ranking = _UserRank(**ranking) + + @dataclasses.dataclass class _UserRankTablePayload: """_UserRankTablePayload""" @@ -14444,6 +15024,166 @@ def platformReportStats( check_=check_)) +AiEditorialGenerateResponse = _OmegaUp_Controllers_AiEditorial__apiGenerate +"""The return type of the AiEditorialGenerate API.""" + +AiEditorialStatusResponse = _OmegaUp_Controllers_AiEditorial__apiStatus +"""The return type of the AiEditorialStatus API.""" + + +class AiEditorial: + r"""AI Editorial Controller + """ + def __init__(self, client: 'Client') -> None: + self._client = client + + def generate( + self, + *, + language: str, + problem_alias: str, + auth_token: Optional[str] = None, + # Out-of-band parameters: + files_: Optional[Mapping[str, BinaryIO]] = None, + check_: bool = True, + timeout_: datetime.timedelta = _DEFAULT_TIMEOUT + ) -> AiEditorialGenerateResponse: + r"""Generate AI editorial for a problem + + Args: + language: + problem_alias: + auth_token: + + Returns: + The API result object. + """ + parameters: Dict[str, str] = { + 'language': language, + 'problem_alias': problem_alias, + } + if auth_token is not None: + parameters['auth_token'] = auth_token + return _OmegaUp_Controllers_AiEditorial__apiGenerate( + **self._client.query('/api/aiEditorial/generate/', + payload=parameters, + files_=files_, + timeout_=timeout_, + check_=check_)) + + def status( + self, + *, + job_id: str, + # Out-of-band parameters: + files_: Optional[Mapping[str, BinaryIO]] = None, + check_: bool = True, + timeout_: datetime.timedelta = _DEFAULT_TIMEOUT + ) -> AiEditorialStatusResponse: + r"""Get status of an AI editorial job + + Args: + job_id: + + Returns: + The API result object. + """ + parameters: Dict[str, str] = { + 'job_id': job_id, + } + return _OmegaUp_Controllers_AiEditorial__apiStatus( + **self._client.query('/api/aiEditorial/status/', + payload=parameters, + files_=files_, + timeout_=timeout_, + check_=check_)) + + def review( + self, + *, + action: str, + job_id: str, + language: Optional[str] = None, + # Out-of-band parameters: + files_: Optional[Mapping[str, BinaryIO]] = None, + check_: bool = True, + timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None: + r"""Review and approve/reject an AI editorial + + When approved, the editorial is published to gitserver + + Args: + action: + job_id: + language: + + Returns: + The API result object. + """ + parameters: Dict[str, str] = { + 'action': action, + 'job_id': job_id, + } + if language is not None: + parameters['language'] = language + self._client.query('/api/aiEditorial/review/', + payload=parameters, + files_=files_, + timeout_=timeout_, + check_=check_) + + def updateJob( + self, + *, + job_id: str, + status: str, + error_message: Optional[str] = None, + md_en: Optional[str] = None, + md_es: Optional[str] = None, + md_pt: Optional[str] = None, + validation_verdict: Optional[str] = None, + # Out-of-band parameters: + files_: Optional[Mapping[str, BinaryIO]] = None, + check_: bool = True, + timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None: + r"""Update job status and content from AI worker + + This endpoint is called by the Python AI worker to update job status + and content in the database after processing completion. + + Args: + job_id: + status: + error_message: + md_en: + md_es: + md_pt: + validation_verdict: + + Returns: + The API result object. + """ + parameters: Dict[str, str] = { + 'job_id': job_id, + 'status': status, + } + if error_message is not None: + parameters['error_message'] = error_message + if md_en is not None: + parameters['md_en'] = md_en + if md_es is not None: + parameters['md_es'] = md_es + if md_pt is not None: + parameters['md_pt'] = md_pt + if validation_verdict is not None: + parameters['validation_verdict'] = validation_verdict + self._client.query('/api/aiEditorial/updateJob/', + payload=parameters, + files_=files_, + timeout_=timeout_, + check_=check_) + + AuthorizationProblemResponse = _OmegaUp_Controllers_Authorization__apiProblem """The return type of the AuthorizationProblem API.""" @@ -14989,8 +15729,8 @@ def list( page_size: int, query: str, tab_name: str, - active: Optional[int] = None, - admission_mode: Optional[Any] = None, + admission_mode: Optional[str] = None, + filter: Optional[str] = None, participating: Optional[int] = None, recommended: Optional[int] = None, sort_order: Optional[str] = None, @@ -15006,8 +15746,8 @@ def list( page_size: query: tab_name: - active: admission_mode: + filter: participating: recommended: sort_order: @@ -15021,10 +15761,10 @@ def list( 'query': query, 'tab_name': tab_name, } - if active is not None: - parameters['active'] = str(active) if admission_mode is not None: - parameters['admission_mode'] = str(admission_mode) + parameters['admission_mode'] = admission_mode + if filter is not None: + parameters['filter'] = filter if participating is not None: parameters['participating'] = str(participating) if recommended is not None: @@ -15468,6 +16208,7 @@ def create( penalty_type: Optional[str] = None, points_decay_factor: Optional[float] = None, problems: Optional[str] = None, + recommended: Optional[bool] = None, requests_user_information: Optional[bool] = None, score_mode: Optional[str] = None, scoreboard: Optional[float] = None, @@ -15498,6 +16239,7 @@ def create( penalty_type: points_decay_factor: problems: + recommended: requests_user_information: score_mode: scoreboard: @@ -15541,6 +16283,8 @@ def create( parameters['points_decay_factor'] = str(points_decay_factor) if problems is not None: parameters['problems'] = problems + if recommended is not None: + parameters['recommended'] = str(recommended) if requests_user_information is not None: parameters['requests_user_information'] = str( requests_user_information) @@ -16278,6 +17022,7 @@ def update( penalty_type: Optional[str] = None, points_decay_factor: Optional[float] = None, problems: Optional[str] = None, + recommended: Optional[bool] = None, requests_user_information: Optional[str] = None, score_mode: Optional[str] = None, scoreboard: Optional[float] = None, @@ -16311,6 +17056,7 @@ def update( penalty_type: points_decay_factor: problems: + recommended: requests_user_information: score_mode: scoreboard: @@ -16358,6 +17104,8 @@ def update( parameters['points_decay_factor'] = str(points_decay_factor) if problems is not None: parameters['problems'] = problems + if recommended is not None: + parameters['recommended'] = str(recommended) if requests_user_information is not None: parameters['requests_user_information'] = requests_user_information if score_mode is not None: @@ -16566,7 +17314,7 @@ def setRecommended( check_: bool = True, timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None: r"""Given a contest_alias, sets the recommended flag on/off. - Only omegaUp admins can call this API. + Only omegaUp admins and support team members can call this API. Args: contest_alias: @@ -16699,6 +17447,9 @@ def archive( CourseDetailsResponse = _CourseDetails """The return type of the CourseDetails API.""" +CourseToggleTeachingAssistantResponse = _OmegaUp_Controllers_Course__apiToggleTeachingAssistant +"""The return type of the CourseToggleTeachingAssistant API.""" + CourseClarificationsResponse = _OmegaUp_Controllers_Course__apiClarifications """The return type of the CourseClarifications API.""" @@ -18113,6 +18864,33 @@ def update( timeout_=timeout_, check_=check_) + def toggleTeachingAssistant( + self, + *, + course_alias: str, + # Out-of-band parameters: + files_: Optional[Mapping[str, BinaryIO]] = None, + check_: bool = True, + timeout_: datetime.timedelta = _DEFAULT_TIMEOUT + ) -> CourseToggleTeachingAssistantResponse: + r"""Toggles the AI Teaching Assistant feature for a course + + Args: + course_alias: + + Returns: + The API result object. + """ + parameters: Dict[str, str] = { + 'course_alias': course_alias, + } + return _OmegaUp_Controllers_Course__apiToggleTeachingAssistant( + **self._client.query('/api/course/toggleTeachingAssistant/', + payload=parameters, + files_=files_, + timeout_=timeout_, + check_=check_)) + def clarifications( self, *, @@ -19173,6 +19951,9 @@ def readNotifications( ProblemRandomKarelProblemResponse = _OmegaUp_Controllers_Problem__apiRandomKarelProblem """The return type of the ProblemRandomKarelProblem API.""" +ProblemConvertZipToCdpResponse = _OmegaUp_Controllers_Problem__apiConvertZipToCdp +"""The return type of the ProblemConvertZipToCdp API.""" + class Problem: r"""ProblemsController @@ -20285,24 +21066,24 @@ def listForTypeahead( def list( self, *, - only_quality_seal: bool, difficulty: Optional[str] = None, difficulty_range: Optional[str] = None, - language: Optional[Any] = None, + language: Optional[str] = None, level: Optional[str] = None, max_difficulty: Optional[int] = None, min_difficulty: Optional[int] = None, min_visibility: Optional[int] = None, offset: Optional[int] = None, - only_karel: Optional[Any] = None, - order_by: Optional[Any] = None, + only_karel: Optional[bool] = None, + only_quality_seal: Optional[bool] = None, + order_by: Optional[str] = None, page: Optional[int] = None, programming_languages: Optional[str] = None, query: Optional[str] = None, - require_all_tags: Optional[Any] = None, + require_all_tags: Optional[bool] = None, rowcount: Optional[int] = None, - some_tags: Optional[Any] = None, - sort_order: Optional[Any] = None, + some_tags: Optional[bool] = None, + sort_order: Optional[str] = None, # Out-of-band parameters: files_: Optional[Mapping[str, BinaryIO]] = None, check_: bool = True, @@ -20311,7 +21092,6 @@ def list( r"""List of public and user's private problems Args: - only_quality_seal: difficulty: difficulty_range: language: @@ -20321,6 +21101,7 @@ def list( min_visibility: offset: only_karel: + only_quality_seal: order_by: page: programming_languages: @@ -20333,15 +21114,13 @@ def list( Returns: The API result object. """ - parameters: Dict[str, str] = { - 'only_quality_seal': str(only_quality_seal), - } + parameters: Dict[str, str] = {} if difficulty is not None: parameters['difficulty'] = difficulty if difficulty_range is not None: parameters['difficulty_range'] = difficulty_range if language is not None: - parameters['language'] = str(language) + parameters['language'] = language if level is not None: parameters['level'] = level if max_difficulty is not None: @@ -20354,8 +21133,10 @@ def list( parameters['offset'] = str(offset) if only_karel is not None: parameters['only_karel'] = str(only_karel) + if only_quality_seal is not None: + parameters['only_quality_seal'] = str(only_quality_seal) if order_by is not None: - parameters['order_by'] = str(order_by) + parameters['order_by'] = order_by if page is not None: parameters['page'] = str(page) if programming_languages is not None: @@ -20369,7 +21150,7 @@ def list( if some_tags is not None: parameters['some_tags'] = str(some_tags) if sort_order is not None: - parameters['sort_order'] = str(sort_order) + parameters['sort_order'] = sort_order return _OmegaUp_Controllers_Problem__apiList( **self._client.query('/api/problem/list/', payload=parameters, @@ -20532,6 +21313,27 @@ def randomKarelProblem( timeout_=timeout_, check_=check_)) + def convertZipToCdp( + self, + *, + # Out-of-band parameters: + files_: Optional[Mapping[str, BinaryIO]] = None, + check_: bool = True, + timeout_: datetime.timedelta = _DEFAULT_TIMEOUT + ) -> ProblemConvertZipToCdpResponse: + r"""Convert an uploaded ZIP file to CDP. + + Returns: + The API result object. + """ + parameters: Dict[str, str] = {} + return _OmegaUp_Controllers_Problem__apiConvertZipToCdp( + **self._client.query('/api/problem/convertZipToCdp/', + payload=parameters, + files_=files_, + timeout_=timeout_, + check_=check_)) + ProblemForfeitedGetCountsResponse = _OmegaUp_Controllers_ProblemForfeited__apiGetCounts """The return type of the ProblemForfeitedGetCounts API.""" @@ -20882,7 +21684,7 @@ def list( rowcount: int, column: Optional[str] = None, query: Optional[str] = None, - status: Optional[Any] = None, + status: Optional[str] = None, # Out-of-band parameters: files_: Optional[Mapping[str, BinaryIO]] = None, check_: bool = True, @@ -20909,7 +21711,7 @@ def list( if query is not None: parameters['query'] = query if status is not None: - parameters['status'] = str(status) + parameters['status'] = status return _OmegaUp_Controllers_QualityNomination__apiList( **self._client.query('/api/qualityNomination/list/', payload=parameters, @@ -21118,6 +21920,12 @@ def update( check_=check_)) +RunExecuteForIDEResponse = _OmegaUp_Controllers_Run__apiExecuteForIDE +"""The return type of the RunExecuteForIDE API.""" + +RunExecuteResponse = _OmegaUp_Controllers_Run__apiExecute +"""The return type of the RunExecute API.""" + RunCreateResponse = _OmegaUp_Controllers_Run__apiCreate """The return type of the RunCreate API.""" @@ -21149,14 +21957,61 @@ class Run: def __init__(self, client: 'Client') -> None: self._client = client + def executeForIDE( + self, + *, + # Out-of-band parameters: + files_: Optional[Mapping[str, BinaryIO]] = None, + check_: bool = True, + timeout_: datetime.timedelta = _DEFAULT_TIMEOUT + ) -> RunExecuteForIDEResponse: + r"""Get the next execution timestamp, no user session required, as the IDE + runs independently. + + Returns: + The API result object. + """ + parameters: Dict[str, str] = {} + return _OmegaUp_Controllers_Run__apiExecuteForIDE( + **self._client.query('/api/run/executeForIDE/', + payload=parameters, + files_=files_, + timeout_=timeout_, + check_=check_)) + + def execute( + self, + *, + # Out-of-band parameters: + files_: Optional[Mapping[str, BinaryIO]] = None, + check_: bool = True, + timeout_: datetime.timedelta = _DEFAULT_TIMEOUT + ) -> RunExecuteResponse: + r"""Get the next execution timestamp for a specific problemset: + - Contest + - Virtual contest + - Practice contest + - Course + + Returns: + The API result object. + """ + parameters: Dict[str, str] = {} + return _OmegaUp_Controllers_Run__apiExecute( + **self._client.query('/api/run/execute/', + payload=parameters, + files_=files_, + timeout_=timeout_, + check_=check_)) + def create( self, *, - contest_alias: str, language: str, problem_alias: str, source: str, - problemset_id: Optional[Any] = None, + contest_alias: Optional[str] = None, + problemset_id: Optional[int] = None, # Out-of-band parameters: files_: Optional[Mapping[str, BinaryIO]] = None, check_: bool = True, @@ -21165,21 +22020,22 @@ def create( r"""Create a new run Args: - contest_alias: language: problem_alias: source: + contest_alias: problemset_id: Returns: The API result object. """ parameters: Dict[str, str] = { - 'contest_alias': contest_alias, 'language': language, 'problem_alias': problem_alias, 'source': source, } + if contest_alias is not None: + parameters['contest_alias'] = contest_alias if problemset_id is not None: parameters['problemset_id'] = str(problemset_id) return _OmegaUp_Controllers_Run__apiCreate( @@ -21810,8 +22666,8 @@ def __init__(self, client: 'Client') -> None: def list( self, *, - query: Optional[Any] = None, - term: Optional[Any] = None, + query: Optional[str] = None, + term: Optional[str] = None, # Out-of-band parameters: files_: Optional[Mapping[str, BinaryIO]] = None, check_: bool = True, @@ -21828,9 +22684,9 @@ def list( """ parameters: Dict[str, str] = {} if query is not None: - parameters['query'] = str(query) + parameters['query'] = query if term is not None: - parameters['term'] = str(term) + parameters['term'] = term return [ _OmegaUp_Controllers_Tag__apiList_entry(**v) for v in self._client.query('/api/tag/list/', @@ -22799,6 +23655,7 @@ def stats( self, *, username: Optional[str] = None, + year: Optional[str] = None, # Out-of-band parameters: files_: Optional[Mapping[str, BinaryIO]] = None, check_: bool = True, @@ -22808,6 +23665,7 @@ def stats( Args: username: + year: Returns: The API result object. @@ -22815,6 +23673,8 @@ def stats( parameters: Dict[str, str] = {} if username is not None: parameters['username'] = username + if year is not None: + parameters['year'] = year return _OmegaUp_Controllers_User__apiStats( **self._client.query('/api/user/stats/', payload=parameters, @@ -23504,6 +24364,7 @@ def __init__(self, 'password': password, })['auth_token'] self._admin: Optional[Admin] = None + self._aiEditorial: Optional[AiEditorial] = None self._authorization: Optional[Authorization] = None self._badge: Optional[Badge] = None self._certificate: Optional[Certificate] = None @@ -23586,6 +24447,13 @@ def admin(self) -> Admin: self._admin = Admin(self) return self._admin + @property + def aiEditorial(self) -> AiEditorial: + """Returns the AiEditorial API.""" + if self._aiEditorial is None: + self._aiEditorial = AiEditorial(self) + return self._aiEditorial + @property def authorization(self) -> Authorization: """Returns the Authorization API."""