1"""A Python implementation of an omegaUp API client.
    2
    3The [omegaUp
    4API](https://github.com/omegaup/omegaup/blob/master/frontend/server/src/Controllers/README.md)
    5allows calling it using an API token (see the docs for `User.createAPIToken`)
    6that does not expire.  This API token can then be provided to the `Client`
    7constructor, which will then allow accessing the rest of the API functions.
    8
    9Sample usage:
   10
   11```python
   12import pprint
   13
   14import omegaup.api
   15
   16client = omegaup.api.Client(api_token='my API token')
   17session = client.session.currentSession()
   18pprint.pprint(session)
   19```
   20"""
   21import dataclasses
   22import datetime
   23import logging
   24import urllib.parse
   25
   26from typing import Any, BinaryIO, Dict, Iterable, Mapping, Optional, Sequence, Union
   27
   28import requests
   29
   30_DEFAULT_TIMEOUT = datetime.timedelta(minutes=1)
   31
   32
   33def _filterKeys(d: Mapping[str, Any], keys: Iterable[str]) -> Dict[str, Any]:
   34    """Returns a copy of the mapping with certain values redacted.
   35
   36    Any of values mapped to the keys in the `keys` iterable will be replaced
   37    with the string '[REDACTED]'.
   38    """
   39    result: Dict[str, Any] = dict(d)
   40    for key in keys:
   41        if key in result:
   42            result[key] = '[REDACTED]'
   43    return result
   44
   45
   46ApiReturnType = Any
   47"""The return type of any of the API requests."""
   48
   49# DAO types
   50
   51
   52@dataclasses.dataclass
   53class _OmegaUp_DAO_VO_Contests:
   54    """Type definition for the \\OmegaUp\\DAO\\VO\\Contests Data Object."""
   55    acl_id: Optional[int]
   56    admission_mode: Optional[str]
   57    alias: Optional[str]
   58    archived: Optional[bool]
   59    certificate_cutoff: Optional[int]
   60    certificates_status: Optional[str]
   61    check_plagiarism: Optional[bool]
   62    contest_for_teams: Optional[bool]
   63    contest_id: Optional[int]
   64    default_show_all_contestants_in_scoreboard: Optional[bool]
   65    description: Optional[str]
   66    feedback: Optional[str]
   67    finish_time: Optional[datetime.datetime]
   68    languages: Optional[str]
   69    last_updated: Optional[datetime.datetime]
   70    partial_score: Optional[bool]
   71    penalty: Optional[int]
   72    penalty_calc_policy: Optional[str]
   73    penalty_type: Optional[str]
   74    plagiarism_threshold: Optional[bool]
   75    points_decay_factor: Optional[float]
   76    problemset_id: Optional[int]
   77    recommended: Optional[bool]
   78    rerun_id: Optional[int]
   79    score_mode: Optional[str]
   80    scoreboard: Optional[int]
   81    show_scoreboard_after: Optional[bool]
   82    start_time: Optional[datetime.datetime]
   83    submissions_gap: Optional[int]
   84    title: Optional[str]
   85    urgent: Optional[bool]
   86    window_length: Optional[int]
   87
   88    def __init__(
   89        self,
   90        *,
   91        acl_id: Optional[int] = None,
   92        admission_mode: Optional[str] = None,
   93        alias: Optional[str] = None,
   94        archived: Optional[bool] = None,
   95        certificate_cutoff: Optional[int] = None,
   96        certificates_status: Optional[str] = None,
   97        check_plagiarism: Optional[bool] = None,
   98        contest_for_teams: Optional[bool] = None,
   99        contest_id: Optional[int] = None,
  100        default_show_all_contestants_in_scoreboard: Optional[bool] = None,
  101        description: Optional[str] = None,
  102        feedback: Optional[str] = None,
  103        finish_time: Optional[int] = None,
  104        languages: Optional[str] = None,
  105        last_updated: Optional[int] = None,
  106        partial_score: Optional[bool] = None,
  107        penalty: Optional[int] = None,
  108        penalty_calc_policy: Optional[str] = None,
  109        penalty_type: Optional[str] = None,
  110        plagiarism_threshold: Optional[bool] = None,
  111        points_decay_factor: Optional[float] = None,
  112        problemset_id: Optional[int] = None,
  113        recommended: Optional[bool] = None,
  114        rerun_id: Optional[int] = None,
  115        score_mode: Optional[str] = None,
  116        scoreboard: Optional[int] = None,
  117        show_scoreboard_after: Optional[bool] = None,
  118        start_time: Optional[int] = None,
  119        submissions_gap: Optional[int] = None,
  120        title: Optional[str] = None,
  121        urgent: Optional[bool] = None,
  122        window_length: Optional[int] = None,
  123        # Ignore any unknown arguments
  124        **_kwargs: Any,
  125    ):
  126        """Create a new \\OmegaUp\\DAO\\VO\\Contests Data Object."""
  127        self.acl_id = acl_id
  128        self.admission_mode = admission_mode
  129        self.alias = alias
  130        self.archived = archived
  131        self.certificate_cutoff = certificate_cutoff
  132        self.certificates_status = certificates_status
  133        self.check_plagiarism = check_plagiarism
  134        self.contest_for_teams = contest_for_teams
  135        self.contest_id = contest_id
  136        self.default_show_all_contestants_in_scoreboard = default_show_all_contestants_in_scoreboard
  137        self.description = description
  138        self.feedback = feedback
  139        if finish_time is not None:
  140            self.finish_time = datetime.datetime.fromtimestamp(finish_time)
  141        else:
  142            self.finish_time = None
  143        self.languages = languages
  144        if last_updated is not None:
  145            self.last_updated = datetime.datetime.fromtimestamp(last_updated)
  146        else:
  147            self.last_updated = None
  148        self.partial_score = partial_score
  149        self.penalty = penalty
  150        self.penalty_calc_policy = penalty_calc_policy
  151        self.penalty_type = penalty_type
  152        self.plagiarism_threshold = plagiarism_threshold
  153        self.points_decay_factor = points_decay_factor
  154        self.problemset_id = problemset_id
  155        self.recommended = recommended
  156        self.rerun_id = rerun_id
  157        self.score_mode = score_mode
  158        self.scoreboard = scoreboard
  159        self.show_scoreboard_after = show_scoreboard_after
  160        if start_time is not None:
  161            self.start_time = datetime.datetime.fromtimestamp(start_time)
  162        else:
  163            self.start_time = None
  164        self.submissions_gap = submissions_gap
  165        self.title = title
  166        self.urgent = urgent
  167        self.window_length = window_length
  168
  169
  170@dataclasses.dataclass
  171class _OmegaUp_DAO_VO_Countries:
  172    """Type definition for the \\OmegaUp\\DAO\\VO\\Countries Data Object."""
  173    country_id: Optional[str]
  174    name: Optional[str]
  175
  176    def __init__(
  177        self,
  178        *,
  179        country_id: Optional[str] = None,
  180        name: Optional[str] = None,
  181        # Ignore any unknown arguments
  182        **_kwargs: Any,
  183    ):
  184        """Create a new \\OmegaUp\\DAO\\VO\\Countries Data Object."""
  185        self.country_id = country_id
  186        self.name = name
  187
  188
  189@dataclasses.dataclass
  190class _OmegaUp_DAO_VO_Identities:
  191    """Type definition for the \\OmegaUp\\DAO\\VO\\Identities Data Object."""
  192    country_id: Optional[str]
  193    current_identity_school_id: Optional[int]
  194    gender: Optional[str]
  195    identity_id: Optional[int]
  196    language_id: Optional[int]
  197    name: Optional[str]
  198    password: Optional[str]
  199    state_id: Optional[str]
  200    user_id: Optional[int]
  201    username: Optional[str]
  202
  203    def __init__(
  204        self,
  205        *,
  206        country_id: Optional[str] = None,
  207        current_identity_school_id: Optional[int] = None,
  208        gender: Optional[str] = None,
  209        identity_id: Optional[int] = None,
  210        language_id: Optional[int] = None,
  211        name: Optional[str] = None,
  212        password: Optional[str] = None,
  213        state_id: Optional[str] = None,
  214        user_id: Optional[int] = None,
  215        username: Optional[str] = None,
  216        # Ignore any unknown arguments
  217        **_kwargs: Any,
  218    ):
  219        """Create a new \\OmegaUp\\DAO\\VO\\Identities Data Object."""
  220        self.country_id = country_id
  221        self.current_identity_school_id = current_identity_school_id
  222        self.gender = gender
  223        self.identity_id = identity_id
  224        self.language_id = language_id
  225        self.name = name
  226        self.password = password
  227        self.state_id = state_id
  228        self.user_id = user_id
  229        self.username = username
  230
  231
  232@dataclasses.dataclass
  233class _OmegaUp_DAO_VO_Users:
  234    """Type definition for the \\OmegaUp\\DAO\\VO\\Users Data Object."""
  235    birth_date: Optional[str]
  236    creation_timestamp: Optional[datetime.datetime]
  237    deletion_token: Optional[str]
  238    facebook_user_id: Optional[str]
  239    git_token: Optional[str]
  240    has_competitive_objective: Optional[bool]
  241    has_learning_objective: Optional[bool]
  242    has_scholar_objective: Optional[bool]
  243    has_teaching_objective: Optional[bool]
  244    hide_problem_tags: Optional[bool]
  245    in_mailing_list: Optional[bool]
  246    is_private: Optional[bool]
  247    main_email_id: Optional[int]
  248    main_identity_id: Optional[int]
  249    parent_email_id: Optional[str]
  250    parent_email_verification_deadline: Optional[datetime.datetime]
  251    parent_email_verification_initial: Optional[datetime.datetime]
  252    parent_verified: Optional[bool]
  253    parental_verification_token: Optional[str]
  254    preferred_language: Optional[str]
  255    reset_digest: Optional[str]
  256    reset_sent_at: Optional[datetime.datetime]
  257    scholar_degree: Optional[str]
  258    user_id: Optional[int]
  259    verification_id: Optional[str]
  260    verified: Optional[bool]
  261
  262    def __init__(
  263        self,
  264        *,
  265        birth_date: Optional[str] = None,
  266        creation_timestamp: Optional[int] = None,
  267        deletion_token: Optional[str] = None,
  268        facebook_user_id: Optional[str] = None,
  269        git_token: Optional[str] = None,
  270        has_competitive_objective: Optional[bool] = None,
  271        has_learning_objective: Optional[bool] = None,
  272        has_scholar_objective: Optional[bool] = None,
  273        has_teaching_objective: Optional[bool] = None,
  274        hide_problem_tags: Optional[bool] = None,
  275        in_mailing_list: Optional[bool] = None,
  276        is_private: Optional[bool] = None,
  277        main_email_id: Optional[int] = None,
  278        main_identity_id: Optional[int] = None,
  279        parent_email_id: Optional[str] = None,
  280        parent_email_verification_deadline: Optional[int] = None,
  281        parent_email_verification_initial: Optional[int] = None,
  282        parent_verified: Optional[bool] = None,
  283        parental_verification_token: Optional[str] = None,
  284        preferred_language: Optional[str] = None,
  285        reset_digest: Optional[str] = None,
  286        reset_sent_at: Optional[int] = None,
  287        scholar_degree: Optional[str] = None,
  288        user_id: Optional[int] = None,
  289        verification_id: Optional[str] = None,
  290        verified: Optional[bool] = None,
  291        # Ignore any unknown arguments
  292        **_kwargs: Any,
  293    ):
  294        """Create a new \\OmegaUp\\DAO\\VO\\Users Data Object."""
  295        self.birth_date = birth_date
  296        if creation_timestamp is not None:
  297            self.creation_timestamp = datetime.datetime.fromtimestamp(
  298                creation_timestamp)
  299        else:
  300            self.creation_timestamp = None
  301        self.deletion_token = deletion_token
  302        self.facebook_user_id = facebook_user_id
  303        self.git_token = git_token
  304        self.has_competitive_objective = has_competitive_objective
  305        self.has_learning_objective = has_learning_objective
  306        self.has_scholar_objective = has_scholar_objective
  307        self.has_teaching_objective = has_teaching_objective
  308        self.hide_problem_tags = hide_problem_tags
  309        self.in_mailing_list = in_mailing_list
  310        self.is_private = is_private
  311        self.main_email_id = main_email_id
  312        self.main_identity_id = main_identity_id
  313        self.parent_email_id = parent_email_id
  314        if parent_email_verification_deadline is not None:
  315            self.parent_email_verification_deadline = datetime.datetime.fromtimestamp(
  316                parent_email_verification_deadline)
  317        else:
  318            self.parent_email_verification_deadline = None
  319        if parent_email_verification_initial is not None:
  320            self.parent_email_verification_initial = datetime.datetime.fromtimestamp(
  321                parent_email_verification_initial)
  322        else:
  323            self.parent_email_verification_initial = None
  324        self.parent_verified = parent_verified
  325        self.parental_verification_token = parental_verification_token
  326        self.preferred_language = preferred_language
  327        self.reset_digest = reset_digest
  328        if reset_sent_at is not None:
  329            self.reset_sent_at = datetime.datetime.fromtimestamp(reset_sent_at)
  330        else:
  331            self.reset_sent_at = None
  332        self.scholar_degree = scholar_degree
  333        self.user_id = user_id
  334        self.verification_id = verification_id
  335        self.verified = verified
  336
  337
  338# Type aliases
  339
  340
  341@dataclasses.dataclass
  342class _ActivityEvent:
  343    """_ActivityEvent"""
  344    classname: str
  345    event: '_Event'
  346    ip: Optional[int]
  347    time: datetime.datetime
  348    username: str
  349
  350    def __init__(
  351        self,
  352        *,
  353        classname: str,
  354        event: Dict[str, Any],
  355        time: int,
  356        username: str,
  357        ip: Optional[int] = None,
  358        # Ignore any unknown arguments
  359        **_kwargs: Any,
  360    ):
  361        self.classname = classname
  362        self.event = _Event(**event)
  363        if ip is not None:
  364            self.ip = ip
  365        else:
  366            self.ip = None
  367        self.time = datetime.datetime.fromtimestamp(time)
  368        self.username = username
  369
  370
  371@dataclasses.dataclass
  372class _ActivityFeedPayload:
  373    """_ActivityFeedPayload"""
  374    alias: str
  375    events: Sequence['_ActivityEvent']
  376    length: int
  377    page: int
  378    pagerItems: Sequence['_PageItem']
  379    type: str
  380
  381    def __init__(
  382        self,
  383        *,
  384        alias: str,
  385        events: Sequence[Dict[str, Any]],
  386        length: int,
  387        page: int,
  388        pagerItems: Sequence[Dict[str, Any]],
  389        type: str,
  390        # Ignore any unknown arguments
  391        **_kwargs: Any,
  392    ):
  393        self.alias = alias
  394        self.events = [_ActivityEvent(**v) for v in events]
  395        self.length = length
  396        self.page = page
  397        self.pagerItems = [_PageItem(**v) for v in pagerItems]
  398        self.type = type
  399
  400
  401@dataclasses.dataclass
  402class _AddedProblem:
  403    """_AddedProblem"""
  404    alias: str
  405    commit: Optional[str]
  406    is_extra_problem: Optional[bool]
  407    points: float
  408
  409    def __init__(
  410        self,
  411        *,
  412        alias: str,
  413        points: float,
  414        commit: Optional[str] = None,
  415        is_extra_problem: Optional[bool] = None,
  416        # Ignore any unknown arguments
  417        **_kwargs: Any,
  418    ):
  419        self.alias = alias
  420        if commit is not None:
  421            self.commit = commit
  422        else:
  423            self.commit = None
  424        if is_extra_problem is not None:
  425            self.is_extra_problem = is_extra_problem
  426        else:
  427            self.is_extra_problem = None
  428        self.points = points
  429
  430
  431@dataclasses.dataclass
  432class _AdminCourses:
  433    """_AdminCourses"""
  434    admin: '_AdminCourses_admin'
  435
  436    def __init__(
  437        self,
  438        *,
  439        admin: Dict[str, Any],
  440        # Ignore any unknown arguments
  441        **_kwargs: Any,
  442    ):
  443        self.admin = _AdminCourses_admin(**admin)
  444
  445
  446@dataclasses.dataclass
  447class _AdminCourses_admin:
  448    """_AdminCourses_admin"""
  449    accessMode: str
  450    activeTab: str
  451    filteredCourses: '_AdminCourses_admin_filteredCourses'
  452
  453    def __init__(
  454        self,
  455        *,
  456        accessMode: str,
  457        activeTab: str,
  458        filteredCourses: Dict[str, Any],
  459        # Ignore any unknown arguments
  460        **_kwargs: Any,
  461    ):
  462        self.accessMode = accessMode
  463        self.activeTab = activeTab
  464        self.filteredCourses = _AdminCourses_admin_filteredCourses(
  465            **filteredCourses)
  466
  467
  468@dataclasses.dataclass
  469class _AdminCourses_admin_filteredCourses:
  470    """_AdminCourses_admin_filteredCourses"""
  471    archived: '_CoursesByTimeType'
  472    current: '_CoursesByTimeType'
  473    past: '_CoursesByTimeType'
  474    teachingAssistant: '_CoursesByTimeType'
  475
  476    def __init__(
  477        self,
  478        *,
  479        archived: Dict[str, Any],
  480        current: Dict[str, Any],
  481        past: Dict[str, Any],
  482        teachingAssistant: Dict[str, Any],
  483        # Ignore any unknown arguments
  484        **_kwargs: Any,
  485    ):
  486        self.archived = _CoursesByTimeType(**archived)
  487        self.current = _CoursesByTimeType(**current)
  488        self.past = _CoursesByTimeType(**past)
  489        self.teachingAssistant = _CoursesByTimeType(**teachingAssistant)
  490
  491
  492@dataclasses.dataclass
  493class _ArenaAssignment:
  494    """_ArenaAssignment"""
  495    alias: Optional[str]
  496    assignment_type: str
  497    description: Optional[str]
  498    director: str
  499    finish_time: Optional[datetime.datetime]
  500    name: Optional[str]
  501    problems: Sequence['_NavbarProblemsetProblem']
  502    problemset_id: int
  503    runs: Sequence['_Run']
  504    start_time: datetime.datetime
  505    totalRuns: Optional[int]
  506
  507    def __init__(
  508        self,
  509        *,
  510        assignment_type: str,
  511        director: str,
  512        problems: Sequence[Dict[str, Any]],
  513        problemset_id: int,
  514        runs: Sequence[Dict[str, Any]],
  515        start_time: int,
  516        alias: Optional[str] = None,
  517        description: Optional[str] = None,
  518        finish_time: Optional[int] = None,
  519        name: Optional[str] = None,
  520        totalRuns: Optional[int] = None,
  521        # Ignore any unknown arguments
  522        **_kwargs: Any,
  523    ):
  524        if alias is not None:
  525            self.alias = alias
  526        else:
  527            self.alias = None
  528        self.assignment_type = assignment_type
  529        if description is not None:
  530            self.description = description
  531        else:
  532            self.description = None
  533        self.director = director
  534        if finish_time is not None:
  535            self.finish_time = datetime.datetime.fromtimestamp(finish_time)
  536        else:
  537            self.finish_time = None
  538        if name is not None:
  539            self.name = name
  540        else:
  541            self.name = None
  542        self.problems = [_NavbarProblemsetProblem(**v) for v in problems]
  543        self.problemset_id = problemset_id
  544        self.runs = [_Run(**v) for v in runs]
  545        self.start_time = datetime.datetime.fromtimestamp(start_time)
  546        if totalRuns is not None:
  547            self.totalRuns = totalRuns
  548        else:
  549            self.totalRuns = None
  550
  551
  552@dataclasses.dataclass
  553class _ArenaContest:
  554    """_ArenaContest"""
  555    alias: str
  556    director: str
  557    finish_time: Optional[datetime.datetime]
  558    rerun_id: Optional[int]
  559    start_time: Optional[datetime.datetime]
  560    title: str
  561    window_length: Optional[int]
  562
  563    def __init__(
  564        self,
  565        *,
  566        alias: str,
  567        director: str,
  568        title: str,
  569        finish_time: Optional[int] = None,
  570        rerun_id: Optional[int] = None,
  571        start_time: Optional[int] = None,
  572        window_length: Optional[int] = None,
  573        # Ignore any unknown arguments
  574        **_kwargs: Any,
  575    ):
  576        self.alias = alias
  577        self.director = director
  578        if finish_time is not None:
  579            self.finish_time = datetime.datetime.fromtimestamp(finish_time)
  580        else:
  581            self.finish_time = None
  582        if rerun_id is not None:
  583            self.rerun_id = rerun_id
  584        else:
  585            self.rerun_id = None
  586        if start_time is not None:
  587            self.start_time = datetime.datetime.fromtimestamp(start_time)
  588        else:
  589            self.start_time = None
  590        self.title = title
  591        if window_length is not None:
  592            self.window_length = window_length
  593        else:
  594            self.window_length = None
  595
  596
  597@dataclasses.dataclass
  598class _ArenaCourseAssignment:
  599    """_ArenaCourseAssignment"""
  600    alias: str
  601    description: str
  602    name: str
  603    problemset_id: int
  604
  605    def __init__(
  606        self,
  607        *,
  608        alias: str,
  609        description: str,
  610        name: str,
  611        problemset_id: int,
  612        # Ignore any unknown arguments
  613        **_kwargs: Any,
  614    ):
  615        self.alias = alias
  616        self.description = description
  617        self.name = name
  618        self.problemset_id = problemset_id
  619
  620
  621@dataclasses.dataclass
  622class _ArenaCourseDetails:
  623    """_ArenaCourseDetails"""
  624    alias: str
  625    assignments: Sequence['_CourseAssignment']
  626    languages: Optional[Sequence[str]]
  627    name: str
  628
  629    def __init__(
  630        self,
  631        *,
  632        alias: str,
  633        assignments: Sequence[Dict[str, Any]],
  634        name: str,
  635        languages: Optional[Sequence[str]] = None,
  636        # Ignore any unknown arguments
  637        **_kwargs: Any,
  638    ):
  639        self.alias = alias
  640        self.assignments = [_CourseAssignment(**v) for v in assignments]
  641        if languages is not None:
  642            self.languages = [v for v in languages]
  643        else:
  644            self.languages = None
  645        self.name = name
  646
  647
  648@dataclasses.dataclass
  649class _ArenaCoursePayload:
  650    """_ArenaCoursePayload"""
  651    assignment: '_ArenaCourseAssignment'
  652    clarifications: Sequence['_Clarification']
  653    course: '_ArenaCourseDetails'
  654    currentProblem: Optional['_ProblemDetails']
  655    problems: Sequence['_ArenaCourseProblem']
  656    runs: Sequence['_Run']
  657    scoreboard: Optional['_Scoreboard']
  658
  659    def __init__(
  660        self,
  661        *,
  662        assignment: Dict[str, Any],
  663        clarifications: Sequence[Dict[str, Any]],
  664        course: Dict[str, Any],
  665        problems: Sequence[Dict[str, Any]],
  666        runs: Sequence[Dict[str, Any]],
  667        currentProblem: Optional[Dict[str, Any]] = None,
  668        scoreboard: Optional[Dict[str, Any]] = None,
  669        # Ignore any unknown arguments
  670        **_kwargs: Any,
  671    ):
  672        self.assignment = _ArenaCourseAssignment(**assignment)
  673        self.clarifications = [_Clarification(**v) for v in clarifications]
  674        self.course = _ArenaCourseDetails(**course)
  675        if currentProblem is not None:
  676            self.currentProblem = _ProblemDetails(**currentProblem)
  677        else:
  678            self.currentProblem = None
  679        self.problems = [_ArenaCourseProblem(**v) for v in problems]
  680        self.runs = [_Run(**v) for v in runs]
  681        if scoreboard is not None:
  682            self.scoreboard = _Scoreboard(**scoreboard)
  683        else:
  684            self.scoreboard = None
  685
  686
  687@dataclasses.dataclass
  688class _ArenaCourseProblem:
  689    """_ArenaCourseProblem"""
  690    alias: str
  691    letter: str
  692    title: str
  693
  694    def __init__(
  695        self,
  696        *,
  697        alias: str,
  698        letter: str,
  699        title: str,
  700        # Ignore any unknown arguments
  701        **_kwargs: Any,
  702    ):
  703        self.alias = alias
  704        self.letter = letter
  705        self.title = title
  706
  707
  708@dataclasses.dataclass
  709class _ArenaProblemDetails:
  710    """_ArenaProblemDetails"""
  711    accepts_submissions: bool
  712    alias: str
  713    commit: str
  714    input_limit: int
  715    languages: Sequence[str]
  716    letter: Optional[str]
  717    points: float
  718    problem_id: Optional[int]
  719    problemsetter: Optional['_ProblemsetterInfo']
  720    quality_seal: bool
  721    runs: Optional[Sequence['_Run']]
  722    settings: Optional['_ProblemSettingsDistrib']
  723    source: Optional[str]
  724    statement: Optional['_ProblemStatement']
  725    title: str
  726    visibility: int
  727
  728    def __init__(
  729        self,
  730        *,
  731        accepts_submissions: bool,
  732        alias: str,
  733        commit: str,
  734        input_limit: int,
  735        languages: Sequence[str],
  736        points: float,
  737        quality_seal: bool,
  738        title: str,
  739        visibility: int,
  740        letter: Optional[str] = None,
  741        problem_id: Optional[int] = None,
  742        problemsetter: Optional[Dict[str, Any]] = None,
  743        runs: Optional[Sequence[Dict[str, Any]]] = None,
  744        settings: Optional[Dict[str, Any]] = None,
  745        source: Optional[str] = None,
  746        statement: Optional[Dict[str, Any]] = None,
  747        # Ignore any unknown arguments
  748        **_kwargs: Any,
  749    ):
  750        self.accepts_submissions = accepts_submissions
  751        self.alias = alias
  752        self.commit = commit
  753        self.input_limit = input_limit
  754        self.languages = [v for v in languages]
  755        if letter is not None:
  756            self.letter = letter
  757        else:
  758            self.letter = None
  759        self.points = points
  760        if problem_id is not None:
  761            self.problem_id = problem_id
  762        else:
  763            self.problem_id = None
  764        if problemsetter is not None:
  765            self.problemsetter = _ProblemsetterInfo(**problemsetter)
  766        else:
  767            self.problemsetter = None
  768        self.quality_seal = quality_seal
  769        if runs is not None:
  770            self.runs = [_Run(**v) for v in runs]
  771        else:
  772            self.runs = None
  773        if settings is not None:
  774            self.settings = _ProblemSettingsDistrib(**settings)
  775        else:
  776            self.settings = None
  777        if source is not None:
  778            self.source = source
  779        else:
  780            self.source = None
  781        if statement is not None:
  782            self.statement = _ProblemStatement(**statement)
  783        else:
  784            self.statement = None
  785        self.title = title
  786        self.visibility = visibility
  787
  788
  789@dataclasses.dataclass
  790class _ArenaProblemset:
  791    """_ArenaProblemset"""
  792    admin: Optional[bool]
  793    admission_mode: Optional[str]
  794    alias: Optional[str]
  795    courseAssignments: Optional[Sequence['_CourseAssignment']]
  796    director: Optional[str]
  797    feedback: Optional[str]
  798    finish_time: Optional[datetime.datetime]
  799    name: Optional[str]
  800    opened: Optional[bool]
  801    original_contest_alias: Optional[str]
  802    original_problemset_id: Optional[int]
  803    problems: Optional[Sequence['_ProblemsetProblem']]
  804    problemset_id: Optional[int]
  805    requests_user_information: Optional[str]
  806    show_penalty: Optional[bool]
  807    start_time: Optional[datetime.datetime]
  808    submission_deadline: Optional[datetime.datetime]
  809    submissions_gap: Optional[int]
  810    title: Optional[str]
  811
  812    def __init__(
  813        self,
  814        *,
  815        admin: Optional[bool] = None,
  816        admission_mode: Optional[str] = None,
  817        alias: Optional[str] = None,
  818        courseAssignments: Optional[Sequence[Dict[str, Any]]] = None,
  819        director: Optional[str] = None,
  820        feedback: Optional[str] = None,
  821        finish_time: Optional[int] = None,
  822        name: Optional[str] = None,
  823        opened: Optional[bool] = None,
  824        original_contest_alias: Optional[str] = None,
  825        original_problemset_id: Optional[int] = None,
  826        problems: Optional[Sequence[Dict[str, Any]]] = None,
  827        problemset_id: Optional[int] = None,
  828        requests_user_information: Optional[str] = None,
  829        show_penalty: Optional[bool] = None,
  830        start_time: Optional[int] = None,
  831        submission_deadline: Optional[int] = None,
  832        submissions_gap: Optional[int] = None,
  833        title: Optional[str] = None,
  834        # Ignore any unknown arguments
  835        **_kwargs: Any,
  836    ):
  837        if admin is not None:
  838            self.admin = admin
  839        else:
  840            self.admin = None
  841        if admission_mode is not None:
  842            self.admission_mode = admission_mode
  843        else:
  844            self.admission_mode = None
  845        if alias is not None:
  846            self.alias = alias
  847        else:
  848            self.alias = None
  849        if courseAssignments is not None:
  850            self.courseAssignments = [
  851                _CourseAssignment(**v) for v in courseAssignments
  852            ]
  853        else:
  854            self.courseAssignments = None
  855        if director is not None:
  856            self.director = director
  857        else:
  858            self.director = None
  859        if feedback is not None:
  860            self.feedback = feedback
  861        else:
  862            self.feedback = None
  863        if finish_time is not None:
  864            self.finish_time = datetime.datetime.fromtimestamp(finish_time)
  865        else:
  866            self.finish_time = None
  867        if name is not None:
  868            self.name = name
  869        else:
  870            self.name = None
  871        if opened is not None:
  872            self.opened = opened
  873        else:
  874            self.opened = None
  875        if original_contest_alias is not None:
  876            self.original_contest_alias = original_contest_alias
  877        else:
  878            self.original_contest_alias = None
  879        if original_problemset_id is not None:
  880            self.original_problemset_id = original_problemset_id
  881        else:
  882            self.original_problemset_id = None
  883        if problems is not None:
  884            self.problems = [_ProblemsetProblem(**v) for v in problems]
  885        else:
  886            self.problems = None
  887        if problemset_id is not None:
  888            self.problemset_id = problemset_id
  889        else:
  890            self.problemset_id = None
  891        if requests_user_information is not None:
  892            self.requests_user_information = requests_user_information
  893        else:
  894            self.requests_user_information = None
  895        if show_penalty is not None:
  896            self.show_penalty = show_penalty
  897        else:
  898            self.show_penalty = None
  899        if start_time is not None:
  900            self.start_time = datetime.datetime.fromtimestamp(start_time)
  901        else:
  902            self.start_time = None
  903        if submission_deadline is not None:
  904            self.submission_deadline = datetime.datetime.fromtimestamp(
  905                submission_deadline)
  906        else:
  907            self.submission_deadline = None
  908        if submissions_gap is not None:
  909            self.submissions_gap = submissions_gap
  910        else:
  911            self.submissions_gap = None
  912        if title is not None:
  913            self.title = title
  914        else:
  915            self.title = None
  916
  917
  918@dataclasses.dataclass
  919class _AssignmentDetails:
  920    """_AssignmentDetails"""
  921    admin: bool
  922    alias: str
  923    assignmentType: str
  924    courseAssignments: Sequence['_CourseAssignment']
  925    description: str
  926    director: str
  927    finishTime: Optional[datetime.datetime]
  928    name: str
  929    problems: Sequence['_ProblemsetProblem']
  930    problemsetId: int
  931    startTime: datetime.datetime
  932
  933    def __init__(
  934        self,
  935        *,
  936        admin: bool,
  937        alias: str,
  938        assignmentType: str,
  939        courseAssignments: Sequence[Dict[str, Any]],
  940        description: str,
  941        director: str,
  942        name: str,
  943        problems: Sequence[Dict[str, Any]],
  944        problemsetId: int,
  945        startTime: int,
  946        finishTime: Optional[int] = None,
  947        # Ignore any unknown arguments
  948        **_kwargs: Any,
  949    ):
  950        self.admin = admin
  951        self.alias = alias
  952        self.assignmentType = assignmentType
  953        self.courseAssignments = [
  954            _CourseAssignment(**v) for v in courseAssignments
  955        ]
  956        self.description = description
  957        self.director = director
  958        if finishTime is not None:
  959            self.finishTime = datetime.datetime.fromtimestamp(finishTime)
  960        else:
  961            self.finishTime = None
  962        self.name = name
  963        self.problems = [_ProblemsetProblem(**v) for v in problems]
  964        self.problemsetId = problemsetId
  965        self.startTime = datetime.datetime.fromtimestamp(startTime)
  966
  967
  968@dataclasses.dataclass
  969class _AssignmentDetailsPayload:
  970    """_AssignmentDetailsPayload"""
  971    courseDetails: '_CourseDetails'
  972    currentAssignment: '_ArenaAssignment'
  973    isTeachingAssistant: bool
  974    scoreboard: Optional['_Scoreboard']
  975    shouldShowFirstAssociatedIdentityRunWarning: bool
  976    showRanking: bool
  977
  978    def __init__(
  979        self,
  980        *,
  981        courseDetails: Dict[str, Any],
  982        currentAssignment: Dict[str, Any],
  983        isTeachingAssistant: bool,
  984        shouldShowFirstAssociatedIdentityRunWarning: bool,
  985        showRanking: bool,
  986        scoreboard: Optional[Dict[str, Any]] = None,
  987        # Ignore any unknown arguments
  988        **_kwargs: Any,
  989    ):
  990        self.courseDetails = _CourseDetails(**courseDetails)
  991        self.currentAssignment = _ArenaAssignment(**currentAssignment)
  992        self.isTeachingAssistant = isTeachingAssistant
  993        if scoreboard is not None:
  994            self.scoreboard = _Scoreboard(**scoreboard)
  995        else:
  996            self.scoreboard = None
  997        self.shouldShowFirstAssociatedIdentityRunWarning = shouldShowFirstAssociatedIdentityRunWarning
  998        self.showRanking = showRanking
  999
 1000
 1001@dataclasses.dataclass
 1002class _AssignmentsProblemsPoints:
 1003    """_AssignmentsProblemsPoints"""
 1004    alias: str
 1005    extraPoints: float
 1006    name: str
 1007    order: int
 1008    points: float
 1009    problems: Sequence['_AssignmentsProblemsPoints_problems_entry']
 1010
 1011    def __init__(
 1012        self,
 1013        *,
 1014        alias: str,
 1015        extraPoints: float,
 1016        name: str,
 1017        order: int,
 1018        points: float,
 1019        problems: Sequence[Dict[str, Any]],
 1020        # Ignore any unknown arguments
 1021        **_kwargs: Any,
 1022    ):
 1023        self.alias = alias
 1024        self.extraPoints = extraPoints
 1025        self.name = name
 1026        self.order = order
 1027        self.points = points
 1028        self.problems = [
 1029            _AssignmentsProblemsPoints_problems_entry(**v) for v in problems
 1030        ]
 1031
 1032
 1033@dataclasses.dataclass
 1034class _AssignmentsProblemsPoints_problems_entry:
 1035    """_AssignmentsProblemsPoints_problems_entry"""
 1036    alias: str
 1037    isExtraProblem: bool
 1038    order: int
 1039    points: float
 1040    title: str
 1041
 1042    def __init__(
 1043        self,
 1044        *,
 1045        alias: str,
 1046        isExtraProblem: bool,
 1047        order: int,
 1048        points: float,
 1049        title: str,
 1050        # Ignore any unknown arguments
 1051        **_kwargs: Any,
 1052    ):
 1053        self.alias = alias
 1054        self.isExtraProblem = isExtraProblem
 1055        self.order = order
 1056        self.points = points
 1057        self.title = title
 1058
 1059
 1060@dataclasses.dataclass
 1061class _AssociatedIdentity:
 1062    """_AssociatedIdentity"""
 1063    default: bool
 1064    username: str
 1065
 1066    def __init__(
 1067        self,
 1068        *,
 1069        default: bool,
 1070        username: str,
 1071        # Ignore any unknown arguments
 1072        **_kwargs: Any,
 1073    ):
 1074        self.default = default
 1075        self.username = username
 1076
 1077
 1078@dataclasses.dataclass
 1079class _AuthIdentityExt:
 1080    """_AuthIdentityExt"""
 1081    currentIdentity: '_IdentityExt'
 1082    loginIdentity: '_IdentityExt'
 1083
 1084    def __init__(
 1085        self,
 1086        *,
 1087        currentIdentity: Dict[str, Any],
 1088        loginIdentity: Dict[str, Any],
 1089        # Ignore any unknown arguments
 1090        **_kwargs: Any,
 1091    ):
 1092        self.currentIdentity = _IdentityExt(**currentIdentity)
 1093        self.loginIdentity = _IdentityExt(**loginIdentity)
 1094
 1095
 1096@dataclasses.dataclass
 1097class _AuthorRankTablePayload:
 1098    """_AuthorRankTablePayload"""
 1099    length: int
 1100    page: int
 1101    pagerItems: Sequence['_PageItem']
 1102    ranking: '_AuthorsRank'
 1103
 1104    def __init__(
 1105        self,
 1106        *,
 1107        length: int,
 1108        page: int,
 1109        pagerItems: Sequence[Dict[str, Any]],
 1110        ranking: Dict[str, Any],
 1111        # Ignore any unknown arguments
 1112        **_kwargs: Any,
 1113    ):
 1114        self.length = length
 1115        self.page = page
 1116        self.pagerItems = [_PageItem(**v) for v in pagerItems]
 1117        self.ranking = _AuthorsRank(**ranking)
 1118
 1119
 1120@dataclasses.dataclass
 1121class _AuthorsRank:
 1122    """_AuthorsRank"""
 1123    ranking: Sequence['_AuthorsRank_ranking_entry']
 1124    total: int
 1125
 1126    def __init__(
 1127        self,
 1128        *,
 1129        ranking: Sequence[Dict[str, Any]],
 1130        total: int,
 1131        # Ignore any unknown arguments
 1132        **_kwargs: Any,
 1133    ):
 1134        self.ranking = [_AuthorsRank_ranking_entry(**v) for v in ranking]
 1135        self.total = total
 1136
 1137
 1138@dataclasses.dataclass
 1139class _AuthorsRank_ranking_entry:
 1140    """_AuthorsRank_ranking_entry"""
 1141    author_ranking: Optional[int]
 1142    author_score: float
 1143    classname: str
 1144    country_id: Optional[str]
 1145    name: Optional[str]
 1146    username: str
 1147
 1148    def __init__(
 1149        self,
 1150        *,
 1151        author_score: float,
 1152        classname: str,
 1153        username: str,
 1154        author_ranking: Optional[int] = None,
 1155        country_id: Optional[str] = None,
 1156        name: Optional[str] = None,
 1157        # Ignore any unknown arguments
 1158        **_kwargs: Any,
 1159    ):
 1160        if author_ranking is not None:
 1161            self.author_ranking = author_ranking
 1162        else:
 1163            self.author_ranking = None
 1164        self.author_score = author_score
 1165        self.classname = classname
 1166        if country_id is not None:
 1167            self.country_id = country_id
 1168        else:
 1169            self.country_id = None
 1170        if name is not None:
 1171            self.name = name
 1172        else:
 1173            self.name = None
 1174        self.username = username
 1175
 1176
 1177@dataclasses.dataclass
 1178class _Badge:
 1179    """_Badge"""
 1180    assignation_time: Optional[datetime.datetime]
 1181    badge_alias: str
 1182    first_assignation: Optional[datetime.datetime]
 1183    owners_count: int
 1184    total_users: int
 1185
 1186    def __init__(
 1187        self,
 1188        *,
 1189        badge_alias: str,
 1190        owners_count: int,
 1191        total_users: int,
 1192        assignation_time: Optional[int] = None,
 1193        first_assignation: Optional[int] = None,
 1194        # Ignore any unknown arguments
 1195        **_kwargs: Any,
 1196    ):
 1197        if assignation_time is not None:
 1198            self.assignation_time = datetime.datetime.fromtimestamp(
 1199                assignation_time)
 1200        else:
 1201            self.assignation_time = None
 1202        self.badge_alias = badge_alias
 1203        if first_assignation is not None:
 1204            self.first_assignation = datetime.datetime.fromtimestamp(
 1205                first_assignation)
 1206        else:
 1207            self.first_assignation = None
 1208        self.owners_count = owners_count
 1209        self.total_users = total_users
 1210
 1211
 1212@dataclasses.dataclass
 1213class _BadgeDetailsPayload:
 1214    """_BadgeDetailsPayload"""
 1215    badge: '_Badge'
 1216
 1217    def __init__(
 1218        self,
 1219        *,
 1220        badge: Dict[str, Any],
 1221        # Ignore any unknown arguments
 1222        **_kwargs: Any,
 1223    ):
 1224        self.badge = _Badge(**badge)
 1225
 1226
 1227@dataclasses.dataclass
 1228class _BadgeListPayload:
 1229    """_BadgeListPayload"""
 1230    badges: Sequence[str]
 1231    ownedBadges: Sequence['_Badge']
 1232
 1233    def __init__(
 1234        self,
 1235        *,
 1236        badges: Sequence[str],
 1237        ownedBadges: Sequence[Dict[str, Any]],
 1238        # Ignore any unknown arguments
 1239        **_kwargs: Any,
 1240    ):
 1241        self.badges = [v for v in badges]
 1242        self.ownedBadges = [_Badge(**v) for v in ownedBadges]
 1243
 1244
 1245@dataclasses.dataclass
 1246class _BestSolvers:
 1247    """_BestSolvers"""
 1248    classname: str
 1249    language: str
 1250    memory: float
 1251    runtime: float
 1252    time: datetime.datetime
 1253    username: str
 1254
 1255    def __init__(
 1256        self,
 1257        *,
 1258        classname: str,
 1259        language: str,
 1260        memory: float,
 1261        runtime: float,
 1262        time: int,
 1263        username: str,
 1264        # Ignore any unknown arguments
 1265        **_kwargs: Any,
 1266    ):
 1267        self.classname = classname
 1268        self.language = language
 1269        self.memory = memory
 1270        self.runtime = runtime
 1271        self.time = datetime.datetime.fromtimestamp(time)
 1272        self.username = username
 1273
 1274
 1275@dataclasses.dataclass
 1276class _CachedExtraProfileDetails:
 1277    """_CachedExtraProfileDetails"""
 1278    badges: Sequence[str]
 1279    contests: Dict[str, '_UserProfileContests_value']
 1280    createdContests: Sequence['_Contest']
 1281    createdCourses: Sequence['_Course']
 1282    createdProblems: Sequence['_Problem']
 1283    solvedProblems: Sequence['_Problem']
 1284    stats: Sequence['_UserProfileStats']
 1285    unsolvedProblems: Sequence['_Problem']
 1286
 1287    def __init__(
 1288        self,
 1289        *,
 1290        badges: Sequence[str],
 1291        contests: Dict[str, Dict[str, Any]],
 1292        createdContests: Sequence[Dict[str, Any]],
 1293        createdCourses: Sequence[Dict[str, Any]],
 1294        createdProblems: Sequence[Dict[str, Any]],
 1295        solvedProblems: Sequence[Dict[str, Any]],
 1296        stats: Sequence[Dict[str, Any]],
 1297        unsolvedProblems: Sequence[Dict[str, Any]],
 1298        # Ignore any unknown arguments
 1299        **_kwargs: Any,
 1300    ):
 1301        self.badges = [v for v in badges]
 1302        self.contests = {
 1303            k: _UserProfileContests_value(**v)
 1304            for k, v in contests.items()
 1305        }
 1306        self.createdContests = [_Contest(**v) for v in createdContests]
 1307        self.createdCourses = [_Course(**v) for v in createdCourses]
 1308        self.createdProblems = [_Problem(**v) for v in createdProblems]
 1309        self.solvedProblems = [_Problem(**v) for v in solvedProblems]
 1310        self.stats = [_UserProfileStats(**v) for v in stats]
 1311        self.unsolvedProblems = [_Problem(**v) for v in unsolvedProblems]
 1312
 1313
 1314@dataclasses.dataclass
 1315class _CaseResult:
 1316    """_CaseResult"""
 1317    contest_score: float
 1318    max_score: float
 1319    meta: '_RunMetadata'
 1320    name: str
 1321    out_diff: Optional[str]
 1322    score: float
 1323    verdict: str
 1324
 1325    def __init__(
 1326        self,
 1327        *,
 1328        contest_score: float,
 1329        max_score: float,
 1330        meta: Dict[str, Any],
 1331        name: str,
 1332        score: float,
 1333        verdict: str,
 1334        out_diff: Optional[str] = None,
 1335        # Ignore any unknown arguments
 1336        **_kwargs: Any,
 1337    ):
 1338        self.contest_score = contest_score
 1339        self.max_score = max_score
 1340        self.meta = _RunMetadata(**meta)
 1341        self.name = name
 1342        if out_diff is not None:
 1343            self.out_diff = out_diff
 1344        else:
 1345            self.out_diff = None
 1346        self.score = score
 1347        self.verdict = verdict
 1348
 1349
 1350@dataclasses.dataclass
 1351class _CertificateDetailsPayload:
 1352    """_CertificateDetailsPayload"""
 1353    uuid: str
 1354
 1355    def __init__(
 1356        self,
 1357        *,
 1358        uuid: str,
 1359        # Ignore any unknown arguments
 1360        **_kwargs: Any,
 1361    ):
 1362        self.uuid = uuid
 1363
 1364
 1365@dataclasses.dataclass
 1366class _Clarification:
 1367    """_Clarification"""
 1368    answer: Optional[str]
 1369    assignment_alias: Optional[str]
 1370    author: str
 1371    clarification_id: int
 1372    contest_alias: Optional[str]
 1373    message: str
 1374    problem_alias: str
 1375    public: bool
 1376    receiver: Optional[str]
 1377    time: datetime.datetime
 1378
 1379    def __init__(
 1380        self,
 1381        *,
 1382        author: str,
 1383        clarification_id: int,
 1384        message: str,
 1385        problem_alias: str,
 1386        public: bool,
 1387        time: int,
 1388        answer: Optional[str] = None,
 1389        assignment_alias: Optional[str] = None,
 1390        contest_alias: Optional[str] = None,
 1391        receiver: Optional[str] = None,
 1392        # Ignore any unknown arguments
 1393        **_kwargs: Any,
 1394    ):
 1395        if answer is not None:
 1396            self.answer = answer
 1397        else:
 1398            self.answer = None
 1399        if assignment_alias is not None:
 1400            self.assignment_alias = assignment_alias
 1401        else:
 1402            self.assignment_alias = None
 1403        self.author = author
 1404        self.clarification_id = clarification_id
 1405        if contest_alias is not None:
 1406            self.contest_alias = contest_alias
 1407        else:
 1408            self.contest_alias = None
 1409        self.message = message
 1410        self.problem_alias = problem_alias
 1411        self.public = public
 1412        if receiver is not None:
 1413            self.receiver = receiver
 1414        else:
 1415            self.receiver = None
 1416        self.time = datetime.datetime.fromtimestamp(time)
 1417
 1418
 1419@dataclasses.dataclass
 1420class _CoderOfTheMonth:
 1421    """_CoderOfTheMonth"""
 1422    category: str
 1423    classname: str
 1424    coder_of_the_month_id: int
 1425    country_id: str
 1426    description: Optional[str]
 1427    problems_solved: int
 1428    ranking: int
 1429    school_id: Optional[int]
 1430    score: float
 1431    selected_by: Optional[int]
 1432    time: str
 1433    user_id: int
 1434    username: str
 1435
 1436    def __init__(
 1437        self,
 1438        *,
 1439        category: str,
 1440        classname: str,
 1441        coder_of_the_month_id: int,
 1442        country_id: str,
 1443        problems_solved: int,
 1444        ranking: int,
 1445        score: float,
 1446        time: str,
 1447        user_id: int,
 1448        username: str,
 1449        description: Optional[str] = None,
 1450        school_id: Optional[int] = None,
 1451        selected_by: Optional[int] = None,
 1452        # Ignore any unknown arguments
 1453        **_kwargs: Any,
 1454    ):
 1455        self.category = category
 1456        self.classname = classname
 1457        self.coder_of_the_month_id = coder_of_the_month_id
 1458        self.country_id = country_id
 1459        if description is not None:
 1460            self.description = description
 1461        else:
 1462            self.description = None
 1463        self.problems_solved = problems_solved
 1464        self.ranking = ranking
 1465        if school_id is not None:
 1466            self.school_id = school_id
 1467        else:
 1468            self.school_id = None
 1469        self.score = score
 1470        if selected_by is not None:
 1471            self.selected_by = selected_by
 1472        else:
 1473            self.selected_by = None
 1474        self.time = time
 1475        self.user_id = user_id
 1476        self.username = username
 1477
 1478
 1479@dataclasses.dataclass
 1480class _CoderOfTheMonthList_entry:
 1481    """_CoderOfTheMonthList_entry"""
 1482    classname: str
 1483    country_id: str
 1484    date: str
 1485    gravatar_32: str
 1486    username: str
 1487
 1488    def __init__(
 1489        self,
 1490        *,
 1491        classname: str,
 1492        country_id: str,
 1493        date: str,
 1494        gravatar_32: str,
 1495        username: str,
 1496        # Ignore any unknown arguments
 1497        **_kwargs: Any,
 1498    ):
 1499        self.classname = classname
 1500        self.country_id = country_id
 1501        self.date = date
 1502        self.gravatar_32 = gravatar_32
 1503        self.username = username
 1504
 1505
 1506@dataclasses.dataclass
 1507class _CoderOfTheMonthPayload:
 1508    """_CoderOfTheMonthPayload"""
 1509    candidatesToCoderOfTheMonth: Sequence[
 1510        '_CoderOfTheMonthPayload_candidatesToCoderOfTheMonth_entry']
 1511    category: str
 1512    codersOfCurrentMonth: Sequence['_CoderOfTheMonthList_entry']
 1513    codersOfPreviousMonth: Sequence['_CoderOfTheMonthList_entry']
 1514    isMentor: bool
 1515    options: Optional['_CoderOfTheMonthPayload_options']
 1516
 1517    def __init__(
 1518        self,
 1519        *,
 1520        candidatesToCoderOfTheMonth: Sequence[Dict[str, Any]],
 1521        category: str,
 1522        codersOfCurrentMonth: Sequence[Dict[str, Any]],
 1523        codersOfPreviousMonth: Sequence[Dict[str, Any]],
 1524        isMentor: bool,
 1525        options: Optional[Dict[str, Any]] = None,
 1526        # Ignore any unknown arguments
 1527        **_kwargs: Any,
 1528    ):
 1529        self.candidatesToCoderOfTheMonth = [
 1530            _CoderOfTheMonthPayload_candidatesToCoderOfTheMonth_entry(**v)
 1531            for v in candidatesToCoderOfTheMonth
 1532        ]
 1533        self.category = category
 1534        self.codersOfCurrentMonth = [
 1535            _CoderOfTheMonthList_entry(**v) for v in codersOfCurrentMonth
 1536        ]
 1537        self.codersOfPreviousMonth = [
 1538            _CoderOfTheMonthList_entry(**v) for v in codersOfPreviousMonth
 1539        ]
 1540        self.isMentor = isMentor
 1541        if options is not None:
 1542            self.options = _CoderOfTheMonthPayload_options(**options)
 1543        else:
 1544            self.options = None
 1545
 1546
 1547@dataclasses.dataclass
 1548class _CoderOfTheMonthPayload_candidatesToCoderOfTheMonth_entry:
 1549    """_CoderOfTheMonthPayload_candidatesToCoderOfTheMonth_entry"""
 1550    category: str
 1551    classname: str
 1552    coder_of_the_month_id: int
 1553    country_id: str
 1554    description: Optional[str]
 1555    problems_solved: int
 1556    ranking: int
 1557    school_id: Optional[int]
 1558    score: float
 1559    selected_by: Optional[int]
 1560    time: str
 1561    username: str
 1562
 1563    def __init__(
 1564        self,
 1565        *,
 1566        category: str,
 1567        classname: str,
 1568        coder_of_the_month_id: int,
 1569        country_id: str,
 1570        problems_solved: int,
 1571        ranking: int,
 1572        score: float,
 1573        time: str,
 1574        username: str,
 1575        description: Optional[str] = None,
 1576        school_id: Optional[int] = None,
 1577        selected_by: Optional[int] = None,
 1578        # Ignore any unknown arguments
 1579        **_kwargs: Any,
 1580    ):
 1581        self.category = category
 1582        self.classname = classname
 1583        self.coder_of_the_month_id = coder_of_the_month_id
 1584        self.country_id = country_id
 1585        if description is not None:
 1586            self.description = description
 1587        else:
 1588            self.description = None
 1589        self.problems_solved = problems_solved
 1590        self.ranking = ranking
 1591        if school_id is not None:
 1592            self.school_id = school_id
 1593        else:
 1594            self.school_id = None
 1595        self.score = score
 1596        if selected_by is not None:
 1597            self.selected_by = selected_by
 1598        else:
 1599            self.selected_by = None
 1600        self.time = time
 1601        self.username = username
 1602
 1603
 1604@dataclasses.dataclass
 1605class _CoderOfTheMonthPayload_options:
 1606    """_CoderOfTheMonthPayload_options"""
 1607    canChooseCoder: bool
 1608    coderIsSelected: bool
 1609
 1610    def __init__(
 1611        self,
 1612        *,
 1613        canChooseCoder: bool,
 1614        coderIsSelected: bool,
 1615        # Ignore any unknown arguments
 1616        **_kwargs: Any,
 1617    ):
 1618        self.canChooseCoder = canChooseCoder
 1619        self.coderIsSelected = coderIsSelected
 1620
 1621
 1622@dataclasses.dataclass
 1623class _CollectionDetailsByAuthorPayload:
 1624    """_CollectionDetailsByAuthorPayload"""
 1625    authors: Sequence[str]
 1626    authorsRanking: '_AuthorsRank'
 1627    column: str
 1628    columns: Sequence[str]
 1629    keyword: str
 1630    language: str
 1631    languages: Sequence[str]
 1632    loggedIn: bool
 1633    mode: str
 1634    modes: Sequence[str]
 1635    pagerItems: Sequence['_PageItem']
 1636    problems: Sequence['_ProblemListItem']
 1637    selectedTags: Sequence[str]
 1638    tagData: Sequence['_CollectionDetailsByAuthorPayload_tagData_entry']
 1639    tags: Sequence[str]
 1640
 1641    def __init__(
 1642        self,
 1643        *,
 1644        authors: Sequence[str],
 1645        authorsRanking: Dict[str, Any],
 1646        column: str,
 1647        columns: Sequence[str],
 1648        keyword: str,
 1649        language: str,
 1650        languages: Sequence[str],
 1651        loggedIn: bool,
 1652        mode: str,
 1653        modes: Sequence[str],
 1654        pagerItems: Sequence[Dict[str, Any]],
 1655        problems: Sequence[Dict[str, Any]],
 1656        selectedTags: Sequence[str],
 1657        tagData: Sequence[Dict[str, Any]],
 1658        tags: Sequence[str],
 1659        # Ignore any unknown arguments
 1660        **_kwargs: Any,
 1661    ):
 1662        self.authors = [v for v in authors]
 1663        self.authorsRanking = _AuthorsRank(**authorsRanking)
 1664        self.column = column
 1665        self.columns = [v for v in columns]
 1666        self.keyword = keyword
 1667        self.language = language
 1668        self.languages = [v for v in languages]
 1669        self.loggedIn = loggedIn
 1670        self.mode = mode
 1671        self.modes = [v for v in modes]
 1672        self.pagerItems = [_PageItem(**v) for v in pagerItems]
 1673        self.problems = [_ProblemListItem(**v) for v in problems]
 1674        self.selectedTags = [v for v in selectedTags]
 1675        self.tagData = [
 1676            _CollectionDetailsByAuthorPayload_tagData_entry(**v)
 1677            for v in tagData
 1678        ]
 1679        self.tags = [v for v in tags]
 1680
 1681
 1682@dataclasses.dataclass
 1683class _CollectionDetailsByAuthorPayload_tagData_entry:
 1684    """_CollectionDetailsByAuthorPayload_tagData_entry"""
 1685    name: Optional[str]
 1686
 1687    def __init__(
 1688        self,
 1689        *,
 1690        name: Optional[str] = None,
 1691        # Ignore any unknown arguments
 1692        **_kwargs: Any,
 1693    ):
 1694        if name is not None:
 1695            self.name = name
 1696        else:
 1697            self.name = None
 1698
 1699
 1700@dataclasses.dataclass
 1701class _CollectionDetailsByLevelPayload:
 1702    """_CollectionDetailsByLevelPayload"""
 1703    column: str
 1704    columns: Sequence[str]
 1705    difficulty: str
 1706    frequentTags: Sequence['_TagWithProblemCount']
 1707    keyword: str
 1708    language: str
 1709    languages: Sequence[str]
 1710    level: str
 1711    loggedIn: bool
 1712    mode: str
 1713    modes: Sequence[str]
 1714    pagerItems: Sequence['_PageItem']
 1715    problems: Sequence['_ProblemListItem']
 1716    publicTags: Sequence['_TagWithProblemCount']
 1717    selectedTags: Sequence[str]
 1718    tagData: Sequence['_CollectionDetailsByLevelPayload_tagData_entry']
 1719    tagsList: Sequence[str]
 1720
 1721    def __init__(
 1722        self,
 1723        *,
 1724        column: str,
 1725        columns: Sequence[str],
 1726        difficulty: str,
 1727        frequentTags: Sequence[Dict[str, Any]],
 1728        keyword: str,
 1729        language: str,
 1730        languages: Sequence[str],
 1731        level: str,
 1732        loggedIn: bool,
 1733        mode: str,
 1734        modes: Sequence[str],
 1735        pagerItems: Sequence[Dict[str, Any]],
 1736        problems: Sequence[Dict[str, Any]],
 1737        publicTags: Sequence[Dict[str, Any]],
 1738        selectedTags: Sequence[str],
 1739        tagData: Sequence[Dict[str, Any]],
 1740        tagsList: Sequence[str],
 1741        # Ignore any unknown arguments
 1742        **_kwargs: Any,
 1743    ):
 1744        self.column = column
 1745        self.columns = [v for v in columns]
 1746        self.difficulty = difficulty
 1747        self.frequentTags = [_TagWithProblemCount(**v) for v in frequentTags]
 1748        self.keyword = keyword
 1749        self.language = language
 1750        self.languages = [v for v in languages]
 1751        self.level = level
 1752        self.loggedIn = loggedIn
 1753        self.mode = mode
 1754        self.modes = [v for v in modes]
 1755        self.pagerItems = [_PageItem(**v) for v in pagerItems]
 1756        self.problems = [_ProblemListItem(**v) for v in problems]
 1757        self.publicTags = [_TagWithProblemCount(**v) for v in publicTags]
 1758        self.selectedTags = [v for v in selectedTags]
 1759        self.tagData = [
 1760            _CollectionDetailsByLevelPayload_tagData_entry(**v)
 1761            for v in tagData
 1762        ]
 1763        self.tagsList = [v for v in tagsList]
 1764
 1765
 1766@dataclasses.dataclass
 1767class _CollectionDetailsByLevelPayload_tagData_entry:
 1768    """_CollectionDetailsByLevelPayload_tagData_entry"""
 1769    name: Optional[str]
 1770
 1771    def __init__(
 1772        self,
 1773        *,
 1774        name: Optional[str] = None,
 1775        # Ignore any unknown arguments
 1776        **_kwargs: Any,
 1777    ):
 1778        if name is not None:
 1779            self.name = name
 1780        else:
 1781            self.name = None
 1782
 1783
 1784@dataclasses.dataclass
 1785class _CommonPayload:
 1786    """_CommonPayload"""
 1787    associatedIdentities: Sequence['_AssociatedIdentity']
 1788    currentEmail: str
 1789    currentName: Optional[str]
 1790    currentUsername: str
 1791    gravatarURL128: str
 1792    gravatarURL51: str
 1793    inContest: bool
 1794    isAdmin: bool
 1795    isLoggedIn: bool
 1796    isMainUserIdentity: bool
 1797    isReviewer: bool
 1798    lockDownImage: str
 1799    navbarSection: str
 1800    omegaUpLockDown: bool
 1801    profileProgress: float
 1802    userClassname: str
 1803    userCountry: str
 1804    userTypes: Sequence[str]
 1805
 1806    def __init__(
 1807        self,
 1808        *,
 1809        associatedIdentities: Sequence[Dict[str, Any]],
 1810        currentEmail: str,
 1811        currentUsername: str,
 1812        gravatarURL128: str,
 1813        gravatarURL51: str,
 1814        inContest: bool,
 1815        isAdmin: bool,
 1816        isLoggedIn: bool,
 1817        isMainUserIdentity: bool,
 1818        isReviewer: bool,
 1819        lockDownImage: str,
 1820        navbarSection: str,
 1821        omegaUpLockDown: bool,
 1822        profileProgress: float,
 1823        userClassname: str,
 1824        userCountry: str,
 1825        userTypes: Sequence[str],
 1826        currentName: Optional[str] = None,
 1827        # Ignore any unknown arguments
 1828        **_kwargs: Any,
 1829    ):
 1830        self.associatedIdentities = [
 1831            _AssociatedIdentity(**v) for v in associatedIdentities
 1832        ]
 1833        self.currentEmail = currentEmail
 1834        if currentName is not None:
 1835            self.currentName = currentName
 1836        else:
 1837            self.currentName = None
 1838        self.currentUsername = currentUsername
 1839        self.gravatarURL128 = gravatarURL128
 1840        self.gravatarURL51 = gravatarURL51
 1841        self.inContest = inContest
 1842        self.isAdmin = isAdmin
 1843        self.isLoggedIn = isLoggedIn
 1844        self.isMainUserIdentity = isMainUserIdentity
 1845        self.isReviewer = isReviewer
 1846        self.lockDownImage = lockDownImage
 1847        self.navbarSection = navbarSection
 1848        self.omegaUpLockDown = omegaUpLockDown
 1849        self.profileProgress = profileProgress
 1850        self.userClassname = userClassname
 1851        self.userCountry = userCountry
 1852        self.userTypes = [v for v in userTypes]
 1853
 1854
 1855@dataclasses.dataclass
 1856class _ConsentStatement:
 1857    """_ConsentStatement"""
 1858    contest_alias: str
 1859    privacy_git_object_id: Optional[str]
 1860    share_user_information: Optional[bool]
 1861    statement_type: Optional[str]
 1862
 1863    def __init__(
 1864        self,
 1865        *,
 1866        contest_alias: str,
 1867        privacy_git_object_id: Optional[str] = None,
 1868        share_user_information: Optional[bool] = None,
 1869        statement_type: Optional[str] = None,
 1870        # Ignore any unknown arguments
 1871        **_kwargs: Any,
 1872    ):
 1873        self.contest_alias = contest_alias
 1874        if privacy_git_object_id is not None:
 1875            self.privacy_git_object_id = privacy_git_object_id
 1876        else:
 1877            self.privacy_git_object_id = None
 1878        if share_user_information is not None:
 1879            self.share_user_information = share_user_information
 1880        else:
 1881            self.share_user_information = None
 1882        if statement_type is not None:
 1883            self.statement_type = statement_type
 1884        else:
 1885            self.statement_type = None
 1886
 1887
 1888@dataclasses.dataclass
 1889class _Contest:
 1890    """_Contest"""
 1891    acl_id: Optional[int]
 1892    admission_mode: str
 1893    alias: str
 1894    contest_id: int
 1895    description: str
 1896    feedback: Optional[str]
 1897    finish_time: datetime.datetime
 1898    languages: Optional[str]
 1899    last_updated: datetime.datetime
 1900    original_finish_time: Optional[datetime.datetime]
 1901    partial_score: bool
 1902    penalty: Optional[int]
 1903    penalty_calc_policy: Optional[str]
 1904    penalty_type: Optional[str]
 1905    points_decay_factor: Optional[float]
 1906    problemset_id: int
 1907    recommended: bool
 1908    rerun_id: Optional[int]
 1909    scoreboard: Optional[int]
 1910    scoreboard_url: str
 1911    scoreboard_url_admin: str
 1912    show_scoreboard_after: Optional[int]
 1913    start_time: datetime.datetime
 1914    submissions_gap: Optional[int]
 1915    title: str
 1916    urgent: Optional[int]
 1917    window_length: Optional[int]
 1918
 1919    def __init__(
 1920        self,
 1921        *,
 1922        admission_mode: str,
 1923        alias: str,
 1924        contest_id: int,
 1925        description: str,
 1926        finish_time: int,
 1927        last_updated: int,
 1928        partial_score: bool,
 1929        problemset_id: int,
 1930        recommended: bool,
 1931        scoreboard_url: str,
 1932        scoreboard_url_admin: str,
 1933        start_time: int,
 1934        title: str,
 1935        acl_id: Optional[int] = None,
 1936        feedback: Optional[str] = None,
 1937        languages: Optional[str] = None,
 1938        original_finish_time: Optional[int] = None,
 1939        penalty: Optional[int] = None,
 1940        penalty_calc_policy: Optional[str] = None,
 1941        penalty_type: Optional[str] = None,
 1942        points_decay_factor: Optional[float] = None,
 1943        rerun_id: Optional[int] = None,
 1944        scoreboard: Optional[int] = None,
 1945        show_scoreboard_after: Optional[int] = None,
 1946        submissions_gap: Optional[int] = None,
 1947        urgent: Optional[int] = None,
 1948        window_length: Optional[int] = None,
 1949        # Ignore any unknown arguments
 1950        **_kwargs: Any,
 1951    ):
 1952        if acl_id is not None:
 1953            self.acl_id = acl_id
 1954        else:
 1955            self.acl_id = None
 1956        self.admission_mode = admission_mode
 1957        self.alias = alias
 1958        self.contest_id = contest_id
 1959        self.description = description
 1960        if feedback is not None:
 1961            self.feedback = feedback
 1962        else:
 1963            self.feedback = None
 1964        self.finish_time = datetime.datetime.fromtimestamp(finish_time)
 1965        if languages is not None:
 1966            self.languages = languages
 1967        else:
 1968            self.languages = None
 1969        self.last_updated = datetime.datetime.fromtimestamp(last_updated)
 1970        if original_finish_time is not None:
 1971            self.original_finish_time = datetime.datetime.fromtimestamp(
 1972                original_finish_time)
 1973        else:
 1974            self.original_finish_time = None
 1975        self.partial_score = partial_score
 1976        if penalty is not None:
 1977            self.penalty = penalty
 1978        else:
 1979            self.penalty = None
 1980        if penalty_calc_policy is not None:
 1981            self.penalty_calc_policy = penalty_calc_policy
 1982        else:
 1983            self.penalty_calc_policy = None
 1984        if penalty_type is not None:
 1985            self.penalty_type = penalty_type
 1986        else:
 1987            self.penalty_type = None
 1988        if points_decay_factor is not None:
 1989            self.points_decay_factor = points_decay_factor
 1990        else:
 1991            self.points_decay_factor = None
 1992        self.problemset_id = problemset_id
 1993        self.recommended = recommended
 1994        if rerun_id is not None:
 1995            self.rerun_id = rerun_id
 1996        else:
 1997            self.rerun_id = None
 1998        if scoreboard is not None:
 1999            self.scoreboard = scoreboard
 2000        else:
 2001            self.scoreboard = None
 2002        self.scoreboard_url = scoreboard_url
 2003        self.scoreboard_url_admin = scoreboard_url_admin
 2004        if show_scoreboard_after is not None:
 2005            self.show_scoreboard_after = show_scoreboard_after
 2006        else:
 2007            self.show_scoreboard_after = None
 2008        self.start_time = datetime.datetime.fromtimestamp(start_time)
 2009        if submissions_gap is not None:
 2010            self.submissions_gap = submissions_gap
 2011        else:
 2012            self.submissions_gap = None
 2013        self.title = title
 2014        if urgent is not None:
 2015            self.urgent = urgent
 2016        else:
 2017            self.urgent = None
 2018        if window_length is not None:
 2019            self.window_length = window_length
 2020        else:
 2021            self.window_length = None
 2022
 2023
 2024@dataclasses.dataclass
 2025class _ContestAdmin:
 2026    """_ContestAdmin"""
 2027    role: str
 2028    username: str
 2029
 2030    def __init__(
 2031        self,
 2032        *,
 2033        role: str,
 2034        username: str,
 2035        # Ignore any unknown arguments
 2036        **_kwargs: Any,
 2037    ):
 2038        self.role = role
 2039        self.username = username
 2040
 2041
 2042@dataclasses.dataclass
 2043class _ContestAdminDetails:
 2044    """_ContestAdminDetails"""
 2045    admin: bool
 2046    admission_mode: str
 2047    alias: str
 2048    archived: bool
 2049    available_languages: Dict[str, str]
 2050    contest_for_teams: bool
 2051    default_show_all_contestants_in_scoreboard: bool
 2052    description: str
 2053    director: str
 2054    feedback: str
 2055    finish_time: datetime.datetime
 2056    has_submissions: bool
 2057    languages: Sequence[str]
 2058    needs_basic_information: bool
 2059    opened: bool
 2060    original_contest_alias: Optional[str]
 2061    original_problemset_id: Optional[int]
 2062    partial_score: bool
 2063    penalty: int
 2064    penalty_calc_policy: str
 2065    penalty_type: str
 2066    points_decay_factor: float
 2067    problems: Optional[Sequence['_ProblemsetProblem']]
 2068    problemset_id: int
 2069    requests_user_information: str
 2070    rerun_id: Optional[int]
 2071    scoreboard: int
 2072    scoreboard_url: Optional[str]
 2073    scoreboard_url_admin: Optional[str]
 2074    show_penalty: bool
 2075    show_scoreboard_after: bool
 2076    start_time: datetime.datetime
 2077    submission_deadline: Optional[datetime.datetime]
 2078    submissions_gap: int
 2079    title: str
 2080    window_length: Optional[int]
 2081
 2082    def __init__(
 2083        self,
 2084        *,
 2085        admin: bool,
 2086        admission_mode: str,
 2087        alias: str,
 2088        archived: bool,
 2089        available_languages: Dict[str, str],
 2090        contest_for_teams: bool,
 2091        default_show_all_contestants_in_scoreboard: bool,
 2092        description: str,
 2093        director: str,
 2094        feedback: str,
 2095        finish_time: int,
 2096        has_submissions: bool,
 2097        languages: Sequence[str],
 2098        needs_basic_information: bool,
 2099        opened: bool,
 2100        partial_score: bool,
 2101        penalty: int,
 2102        penalty_calc_policy: str,
 2103        penalty_type: str,
 2104        points_decay_factor: float,
 2105        problemset_id: int,
 2106        requests_user_information: str,
 2107        scoreboard: int,
 2108        show_penalty: bool,
 2109        show_scoreboard_after: bool,
 2110        start_time: int,
 2111        submissions_gap: int,
 2112        title: str,
 2113        original_contest_alias: Optional[str] = None,
 2114        original_problemset_id: Optional[int] = None,
 2115        problems: Optional[Sequence[Dict[str, Any]]] = None,
 2116        rerun_id: Optional[int] = None,
 2117        scoreboard_url: Optional[str] = None,
 2118        scoreboard_url_admin: Optional[str] = None,
 2119        submission_deadline: Optional[int] = None,
 2120        window_length: Optional[int] = None,
 2121        # Ignore any unknown arguments
 2122        **_kwargs: Any,
 2123    ):
 2124        self.admin = admin
 2125        self.admission_mode = admission_mode
 2126        self.alias = alias
 2127        self.archived = archived
 2128        self.available_languages = {
 2129            k: v
 2130            for k, v in available_languages.items()
 2131        }
 2132        self.contest_for_teams = contest_for_teams
 2133        self.default_show_all_contestants_in_scoreboard = default_show_all_contestants_in_scoreboard
 2134        self.description = description
 2135        self.director = director
 2136        self.feedback = feedback
 2137        self.finish_time = datetime.datetime.fromtimestamp(finish_time)
 2138        self.has_submissions = has_submissions
 2139        self.languages = [v for v in languages]
 2140        self.needs_basic_information = needs_basic_information
 2141        self.opened = opened
 2142        if original_contest_alias is not None:
 2143            self.original_contest_alias = original_contest_alias
 2144        else:
 2145            self.original_contest_alias = None
 2146        if original_problemset_id is not None:
 2147            self.original_problemset_id = original_problemset_id
 2148        else:
 2149            self.original_problemset_id = None
 2150        self.partial_score = partial_score
 2151        self.penalty = penalty
 2152        self.penalty_calc_policy = penalty_calc_policy
 2153        self.penalty_type = penalty_type
 2154        self.points_decay_factor = points_decay_factor
 2155        if problems is not None:
 2156            self.problems = [_ProblemsetProblem(**v) for v in problems]
 2157        else:
 2158            self.problems = None
 2159        self.problemset_id = problemset_id
 2160        self.requests_user_information = requests_user_information
 2161        if rerun_id is not None:
 2162            self.rerun_id = rerun_id
 2163        else:
 2164            self.rerun_id = None
 2165        self.scoreboard = scoreboard
 2166        if scoreboard_url is not None:
 2167            self.scoreboard_url = scoreboard_url
 2168        else:
 2169            self.scoreboard_url = None
 2170        if scoreboard_url_admin is not None:
 2171            self.scoreboard_url_admin = scoreboard_url_admin
 2172        else:
 2173            self.scoreboard_url_admin = None
 2174        self.show_penalty = show_penalty
 2175        self.show_scoreboard_after = show_scoreboard_after
 2176        self.start_time = datetime.datetime.fromtimestamp(start_time)
 2177        if submission_deadline is not None:
 2178            self.submission_deadline = datetime.datetime.fromtimestamp(
 2179                submission_deadline)
 2180        else:
 2181            self.submission_deadline = None
 2182        self.submissions_gap = submissions_gap
 2183        self.title = title
 2184        if window_length is not None:
 2185            self.window_length = window_length
 2186        else:
 2187            self.window_length = None
 2188
 2189
 2190@dataclasses.dataclass
 2191class _ContestDetails:
 2192    """_ContestDetails"""
 2193    admin: bool
 2194    admission_mode: str
 2195    alias: str
 2196    archived: bool
 2197    contest_for_teams: bool
 2198    default_show_all_contestants_in_scoreboard: bool
 2199    description: str
 2200    director: str
 2201    feedback: str
 2202    finish_time: datetime.datetime
 2203    has_submissions: bool
 2204    languages: Sequence[str]
 2205    needs_basic_information: bool
 2206    opened: bool
 2207    original_contest_alias: Optional[str]
 2208    original_problemset_id: Optional[int]
 2209    partial_score: bool
 2210    penalty: int
 2211    penalty_calc_policy: str
 2212    penalty_type: str
 2213    points_decay_factor: float
 2214    problems: Sequence['_ProblemsetProblem']
 2215    problemset_id: int
 2216    requests_user_information: str
 2217    rerun_id: Optional[int]
 2218    scoreboard: int
 2219    scoreboard_url: Optional[str]
 2220    scoreboard_url_admin: Optional[str]
 2221    show_penalty: bool
 2222    show_scoreboard_after: bool
 2223    start_time: datetime.datetime
 2224    submission_deadline: Optional[datetime.datetime]
 2225    submissions_gap: int
 2226    title: str
 2227    window_length: Optional[int]
 2228
 2229    def __init__(
 2230        self,
 2231        *,
 2232        admin: bool,
 2233        admission_mode: str,
 2234        alias: str,
 2235        archived: bool,
 2236        contest_for_teams: bool,
 2237        default_show_all_contestants_in_scoreboard: bool,
 2238        description: str,
 2239        director: str,
 2240        feedback: str,
 2241        finish_time: int,
 2242        has_submissions: bool,
 2243        languages: Sequence[str],
 2244        needs_basic_information: bool,
 2245        opened: bool,
 2246        partial_score: bool,
 2247        penalty: int,
 2248        penalty_calc_policy: str,
 2249        penalty_type: str,
 2250        points_decay_factor: float,
 2251        problems: Sequence[Dict[str, Any]],
 2252        problemset_id: int,
 2253        requests_user_information: str,
 2254        scoreboard: int,
 2255        show_penalty: bool,
 2256        show_scoreboard_after: bool,
 2257        start_time: int,
 2258        submissions_gap: int,
 2259        title: str,
 2260        original_contest_alias: Optional[str] = None,
 2261        original_problemset_id: Optional[int] = None,
 2262        rerun_id: Optional[int] = None,
 2263        scoreboard_url: Optional[str] = None,
 2264        scoreboard_url_admin: Optional[str] = None,
 2265        submission_deadline: Optional[int] = None,
 2266        window_length: Optional[int] = None,
 2267        # Ignore any unknown arguments
 2268        **_kwargs: Any,
 2269    ):
 2270        self.admin = admin
 2271        self.admission_mode = admission_mode
 2272        self.alias = alias
 2273        self.archived = archived
 2274        self.contest_for_teams = contest_for_teams
 2275        self.default_show_all_contestants_in_scoreboard = default_show_all_contestants_in_scoreboard
 2276        self.description = description
 2277        self.director = director
 2278        self.feedback = feedback
 2279        self.finish_time = datetime.datetime.fromtimestamp(finish_time)
 2280        self.has_submissions = has_submissions
 2281        self.languages = [v for v in languages]
 2282        self.needs_basic_information = needs_basic_information
 2283        self.opened = opened
 2284        if original_contest_alias is not None:
 2285            self.original_contest_alias = original_contest_alias
 2286        else:
 2287            self.original_contest_alias = None
 2288        if original_problemset_id is not None:
 2289            self.original_problemset_id = original_problemset_id
 2290        else:
 2291            self.original_problemset_id = None
 2292        self.partial_score = partial_score
 2293        self.penalty = penalty
 2294        self.penalty_calc_policy = penalty_calc_policy
 2295        self.penalty_type = penalty_type
 2296        self.points_decay_factor = points_decay_factor
 2297        self.problems = [_ProblemsetProblem(**v) for v in problems]
 2298        self.problemset_id = problemset_id
 2299        self.requests_user_information = requests_user_information
 2300        if rerun_id is not None:
 2301            self.rerun_id = rerun_id
 2302        else:
 2303            self.rerun_id = None
 2304        self.scoreboard = scoreboard
 2305        if scoreboard_url is not None:
 2306            self.scoreboard_url = scoreboard_url
 2307        else:
 2308            self.scoreboard_url = None
 2309        if scoreboard_url_admin is not None:
 2310            self.scoreboard_url_admin = scoreboard_url_admin
 2311        else:
 2312            self.scoreboard_url_admin = None
 2313        self.show_penalty = show_penalty
 2314        self.show_scoreboard_after = show_scoreboard_after
 2315        self.start_time = datetime.datetime.fromtimestamp(start_time)
 2316        if submission_deadline is not None:
 2317            self.submission_deadline = datetime.datetime.fromtimestamp(
 2318                submission_deadline)
 2319        else:
 2320            self.submission_deadline = None
 2321        self.submissions_gap = submissions_gap
 2322        self.title = title
 2323        if window_length is not None:
 2324            self.window_length = window_length
 2325        else:
 2326            self.window_length = None
 2327
 2328
 2329@dataclasses.dataclass
 2330class _ContestDetailsPayload:
 2331    """_ContestDetailsPayload"""
 2332    adminPayload: Optional['_ContestDetailsPayload_adminPayload']
 2333    clarifications: Sequence['_Clarification']
 2334    contest: '_ContestPublicDetails'
 2335    original: Optional['_ContestDetailsPayload_original']
 2336    problems: Sequence['_NavbarProblemsetProblem']
 2337    scoreboard: '_Scoreboard'
 2338    scoreboardEvents: Sequence['_ScoreboardEvent']
 2339    shouldShowFirstAssociatedIdentityRunWarning: bool
 2340    submissionDeadline: Optional[datetime.datetime]
 2341
 2342    def __init__(
 2343        self,
 2344        *,
 2345        clarifications: Sequence[Dict[str, Any]],
 2346        contest: Dict[str, Any],
 2347        problems: Sequence[Dict[str, Any]],
 2348        scoreboard: Dict[str, Any],
 2349        scoreboardEvents: Sequence[Dict[str, Any]],
 2350        shouldShowFirstAssociatedIdentityRunWarning: bool,
 2351        adminPayload: Optional[Dict[str, Any]] = None,
 2352        original: Optional[Dict[str, Any]] = None,
 2353        submissionDeadline: Optional[int] = None,
 2354        # Ignore any unknown arguments
 2355        **_kwargs: Any,
 2356    ):
 2357        if adminPayload is not None:
 2358            self.adminPayload = _ContestDetailsPayload_adminPayload(
 2359                **adminPayload)
 2360        else:
 2361            self.adminPayload = None
 2362        self.clarifications = [_Clarification(**v) for v in clarifications]
 2363        self.contest = _ContestPublicDetails(**contest)
 2364        if original is not None:
 2365            self.original = _ContestDetailsPayload_original(**original)
 2366        else:
 2367            self.original = None
 2368        self.problems = [_NavbarProblemsetProblem(**v) for v in problems]
 2369        self.scoreboard = _Scoreboard(**scoreboard)
 2370        self.scoreboardEvents = [
 2371            _ScoreboardEvent(**v) for v in scoreboardEvents
 2372        ]
 2373        self.shouldShowFirstAssociatedIdentityRunWarning = shouldShowFirstAssociatedIdentityRunWarning
 2374        if submissionDeadline is not None:
 2375            self.submissionDeadline = datetime.datetime.fromtimestamp(
 2376                submissionDeadline)
 2377        else:
 2378            self.submissionDeadline = None
 2379
 2380
 2381@dataclasses.dataclass
 2382class _ContestDetailsPayload_adminPayload:
 2383    """_ContestDetailsPayload_adminPayload"""
 2384    allRuns: Sequence['_Run']
 2385    totalRuns: int
 2386    users: Sequence['_ContestUser']
 2387
 2388    def __init__(
 2389        self,
 2390        *,
 2391        allRuns: Sequence[Dict[str, Any]],
 2392        totalRuns: int,
 2393        users: Sequence[Dict[str, Any]],
 2394        # Ignore any unknown arguments
 2395        **_kwargs: Any,
 2396    ):
 2397        self.allRuns = [_Run(**v) for v in allRuns]
 2398        self.totalRuns = totalRuns
 2399        self.users = [_ContestUser(**v) for v in users]
 2400
 2401
 2402@dataclasses.dataclass
 2403class _ContestDetailsPayload_original:
 2404    """_ContestDetailsPayload_original"""
 2405    contest: _OmegaUp_DAO_VO_Contests
 2406    scoreboard: Optional['_Scoreboard']
 2407    scoreboardEvents: Optional[Sequence['_ScoreboardEvent']]
 2408
 2409    def __init__(
 2410        self,
 2411        *,
 2412        contest: Dict[str, Any],
 2413        scoreboard: Optional[Dict[str, Any]] = None,
 2414        scoreboardEvents: Optional[Sequence[Dict[str, Any]]] = None,
 2415        # Ignore any unknown arguments
 2416        **_kwargs: Any,
 2417    ):
 2418        self.contest = _OmegaUp_DAO_VO_Contests(**contest)
 2419        if scoreboard is not None:
 2420            self.scoreboard = _Scoreboard(**scoreboard)
 2421        else:
 2422            self.scoreboard = None
 2423        if scoreboardEvents is not None:
 2424            self.scoreboardEvents = [
 2425                _ScoreboardEvent(**v) for v in scoreboardEvents
 2426            ]
 2427        else:
 2428            self.scoreboardEvents = None
 2429
 2430
 2431@dataclasses.dataclass
 2432class _ContestEditPayload:
 2433    """_ContestEditPayload"""
 2434    admins: Sequence['_ContestAdmin']
 2435    details: '_ContestAdminDetails'
 2436    group_admins: Sequence['_ContestGroupAdmin']
 2437    groups: Sequence['_ContestGroup']
 2438    problems: Sequence['_ProblemsetProblemWithVersions']
 2439    requests: Sequence['_ContestRequest']
 2440    teams_group: Optional['_ContestGroup']
 2441    users: Sequence['_ContestUser']
 2442
 2443    def __init__(
 2444        self,
 2445        *,
 2446        admins: Sequence[Dict[str, Any]],
 2447        details: Dict[str, Any],
 2448        group_admins: Sequence[Dict[str, Any]],
 2449        groups: Sequence[Dict[str, Any]],
 2450        problems: Sequence[Dict[str, Any]],
 2451        requests: Sequence[Dict[str, Any]],
 2452        users: Sequence[Dict[str, Any]],
 2453        teams_group: Optional[Dict[str, Any]] = None,
 2454        # Ignore any unknown arguments
 2455        **_kwargs: Any,
 2456    ):
 2457        self.admins = [_ContestAdmin(**v) for v in admins]
 2458        self.details = _ContestAdminDetails(**details)
 2459        self.group_admins = [_ContestGroupAdmin(**v) for v in group_admins]
 2460        self.groups = [_ContestGroup(**v) for v in groups]
 2461        self.problems = [_ProblemsetProblemWithVersions(**v) for v in problems]
 2462        self.requests = [_ContestRequest(**v) for v in requests]
 2463        if teams_group is not None:
 2464            self.teams_group = _ContestGroup(**teams_group)
 2465        else:
 2466            self.teams_group = None
 2467        self.users = [_ContestUser(**v) for v in users]
 2468
 2469
 2470@dataclasses.dataclass
 2471class _ContestGroup:
 2472    """_ContestGroup"""
 2473    alias: str
 2474    name: str
 2475
 2476    def __init__(
 2477        self,
 2478        *,
 2479        alias: str,
 2480        name: str,
 2481        # Ignore any unknown arguments
 2482        **_kwargs: Any,
 2483    ):
 2484        self.alias = alias
 2485        self.name = name
 2486
 2487
 2488@dataclasses.dataclass
 2489class _ContestGroupAdmin:
 2490    """_ContestGroupAdmin"""
 2491    alias: str
 2492    name: str
 2493    role: str
 2494
 2495    def __init__(
 2496        self,
 2497        *,
 2498        alias: str,
 2499        name: str,
 2500        role: str,
 2501        # Ignore any unknown arguments
 2502        **_kwargs: Any,
 2503    ):
 2504        self.alias = alias
 2505        self.name = name
 2506        self.role = role
 2507
 2508
 2509@dataclasses.dataclass
 2510class _ContestIntroPayload:
 2511    """_ContestIntroPayload"""
 2512    contest: '_ContestPublicDetails'
 2513    needsBasicInformation: bool
 2514    privacyStatement: '_PrivacyStatement'
 2515    requestsUserInformation: str
 2516
 2517    def __init__(
 2518        self,
 2519        *,
 2520        contest: Dict[str, Any],
 2521        needsBasicInformation: bool,
 2522        privacyStatement: Dict[str, Any],
 2523        requestsUserInformation: str,
 2524        # Ignore any unknown arguments
 2525        **_kwargs: Any,
 2526    ):
 2527        self.contest = _ContestPublicDetails(**contest)
 2528        self.needsBasicInformation = needsBasicInformation
 2529        self.privacyStatement = _PrivacyStatement(**privacyStatement)
 2530        self.requestsUserInformation = requestsUserInformation
 2531
 2532
 2533@dataclasses.dataclass
 2534class _ContestList:
 2535    """_ContestList"""
 2536    current: Sequence['_ContestListItem']
 2537    future: Sequence['_ContestListItem']
 2538    past: Sequence['_ContestListItem']
 2539
 2540    def __init__(
 2541        self,
 2542        *,
 2543        current: Sequence[Dict[str, Any]],
 2544        future: Sequence[Dict[str, Any]],
 2545        past: Sequence[Dict[str, Any]],
 2546        # Ignore any unknown arguments
 2547        **_kwargs: Any,
 2548    ):
 2549        self.current = [_ContestListItem(**v) for v in current]
 2550        self.future = [_ContestListItem(**v) for v in future]
 2551        self.past = [_ContestListItem(**v) for v in past]
 2552
 2553
 2554@dataclasses.dataclass
 2555class _ContestListItem:
 2556    """_ContestListItem"""
 2557    admission_mode: str
 2558    alias: str
 2559    contest_id: int
 2560    contestants: int
 2561    description: str
 2562    finish_time: datetime.datetime
 2563    last_updated: datetime.datetime
 2564    organizer: str
 2565    original_finish_time: datetime.datetime
 2566    partial_score: bool
 2567    participating: bool
 2568    problemset_id: int
 2569    recommended: bool
 2570    rerun_id: Optional[int]
 2571    start_time: datetime.datetime
 2572    title: str
 2573    window_length: Optional[int]
 2574
 2575    def __init__(
 2576        self,
 2577        *,
 2578        admission_mode: str,
 2579        alias: str,
 2580        contest_id: int,
 2581        contestants: int,
 2582        description: str,
 2583        finish_time: int,
 2584        last_updated: int,
 2585        organizer: str,
 2586        original_finish_time: int,
 2587        partial_score: bool,
 2588        participating: bool,
 2589        problemset_id: int,
 2590        recommended: bool,
 2591        start_time: int,
 2592        title: str,
 2593        rerun_id: Optional[int] = None,
 2594        window_length: Optional[int] = None,
 2595        # Ignore any unknown arguments
 2596        **_kwargs: Any,
 2597    ):
 2598        self.admission_mode = admission_mode
 2599        self.alias = alias
 2600        self.contest_id = contest_id
 2601        self.contestants = contestants
 2602        self.description = description
 2603        self.finish_time = datetime.datetime.fromtimestamp(finish_time)
 2604        self.last_updated = datetime.datetime.fromtimestamp(last_updated)
 2605        self.organizer = organizer
 2606        self.original_finish_time = datetime.datetime.fromtimestamp(
 2607            original_finish_time)
 2608        self.partial_score = partial_score
 2609        self.participating = participating
 2610        self.problemset_id = problemset_id
 2611        self.recommended = recommended
 2612        if rerun_id is not None:
 2613            self.rerun_id = rerun_id
 2614        else:
 2615            self.rerun_id = None
 2616        self.start_time = datetime.datetime.fromtimestamp(start_time)
 2617        self.title = title
 2618        if window_length is not None:
 2619            self.window_length = window_length
 2620        else:
 2621            self.window_length = None
 2622
 2623
 2624@dataclasses.dataclass
 2625class _ContestListMinePayload:
 2626    """_ContestListMinePayload"""
 2627    contests: Sequence['_Contest']
 2628    privateContestsAlert: bool
 2629
 2630    def __init__(
 2631        self,
 2632        *,
 2633        contests: Sequence[Dict[str, Any]],
 2634        privateContestsAlert: bool,
 2635        # Ignore any unknown arguments
 2636        **_kwargs: Any,
 2637    ):
 2638        self.contests = [_Contest(**v) for v in contests]
 2639        self.privateContestsAlert = privateContestsAlert
 2640
 2641
 2642@dataclasses.dataclass
 2643class _ContestListPayload:
 2644    """_ContestListPayload"""
 2645    contests: Dict[str, Sequence['_ContestListItem']]
 2646    countContests: Dict[str, int]
 2647    isLogged: bool
 2648    query: Optional[str]
 2649
 2650    def __init__(
 2651        self,
 2652        *,
 2653        contests: Dict[str, Sequence[Dict[str, Any]]],
 2654        countContests: Dict[str, int],
 2655        isLogged: bool,
 2656        query: Optional[str] = None,
 2657        # Ignore any unknown arguments
 2658        **_kwargs: Any,
 2659    ):
 2660        self.contests = {
 2661            k: [_ContestListItem(**v) for v in v]
 2662            for k, v in contests.items()
 2663        }
 2664        self.countContests = {k: v for k, v in countContests.items()}
 2665        self.isLogged = isLogged
 2666        if query is not None:
 2667            self.query = query
 2668        else:
 2669            self.query = None
 2670
 2671
 2672@dataclasses.dataclass
 2673class _ContestListv2Payload:
 2674    """_ContestListv2Payload"""
 2675    contests: '_ContestList'
 2676    countContests: '_ContestListv2Payload_countContests'
 2677    query: Optional[str]
 2678
 2679    def __init__(
 2680        self,
 2681        *,
 2682        contests: Dict[str, Any],
 2683        countContests: Dict[str, Any],
 2684        query: Optional[str] = None,
 2685        # Ignore any unknown arguments
 2686        **_kwargs: Any,
 2687    ):
 2688        self.contests = _ContestList(**contests)
 2689        self.countContests = _ContestListv2Payload_countContests(
 2690            **countContests)
 2691        if query is not None:
 2692            self.query = query
 2693        else:
 2694            self.query = None
 2695
 2696
 2697@dataclasses.dataclass
 2698class _ContestListv2Payload_countContests:
 2699    """_ContestListv2Payload_countContests"""
 2700    current: int
 2701    future: int
 2702    past: int
 2703
 2704    def __init__(
 2705        self,
 2706        *,
 2707        current: int,
 2708        future: int,
 2709        past: int,
 2710        # Ignore any unknown arguments
 2711        **_kwargs: Any,
 2712    ):
 2713        self.current = current
 2714        self.future = future
 2715        self.past = past
 2716
 2717
 2718@dataclasses.dataclass
 2719class _ContestNewPayload:
 2720    """_ContestNewPayload"""
 2721    languages: Dict[str, str]
 2722
 2723    def __init__(
 2724        self,
 2725        *,
 2726        languages: Dict[str, str],
 2727        # Ignore any unknown arguments
 2728        **_kwargs: Any,
 2729    ):
 2730        self.languages = {k: v for k, v in languages.items()}
 2731
 2732
 2733@dataclasses.dataclass
 2734class _ContestParticipated:
 2735    """_ContestParticipated"""
 2736    alias: str
 2737    finish_time: datetime.datetime
 2738    last_updated: datetime.datetime
 2739    start_time: datetime.datetime
 2740    title: str
 2741
 2742    def __init__(
 2743        self,
 2744        *,
 2745        alias: str,
 2746        finish_time: int,
 2747        last_updated: int,
 2748        start_time: int,
 2749        title: str,
 2750        # Ignore any unknown arguments
 2751        **_kwargs: Any,
 2752    ):
 2753        self.alias = alias
 2754        self.finish_time = datetime.datetime.fromtimestamp(finish_time)
 2755        self.last_updated = datetime.datetime.fromtimestamp(last_updated)
 2756        self.start_time = datetime.datetime.fromtimestamp(start_time)
 2757        self.title = title
 2758
 2759
 2760@dataclasses.dataclass
 2761class _ContestPracticeDetailsPayload:
 2762    """_ContestPracticeDetailsPayload"""
 2763    adminPayload: Optional['_ContestPracticeDetailsPayload_adminPayload']
 2764    clarifications: Sequence['_Clarification']
 2765    contest: '_ContestPublicDetails'
 2766    contestAdmin: bool
 2767    original: Optional['_ContestPracticeDetailsPayload_original']
 2768    problems: Sequence['_NavbarProblemsetProblem']
 2769    shouldShowFirstAssociatedIdentityRunWarning: bool
 2770    submissionDeadline: Optional[datetime.datetime]
 2771
 2772    def __init__(
 2773        self,
 2774        *,
 2775        clarifications: Sequence[Dict[str, Any]],
 2776        contest: Dict[str, Any],
 2777        contestAdmin: bool,
 2778        problems: Sequence[Dict[str, Any]],
 2779        shouldShowFirstAssociatedIdentityRunWarning: bool,
 2780        adminPayload: Optional[Dict[str, Any]] = None,
 2781        original: Optional[Dict[str, Any]] = None,
 2782        submissionDeadline: Optional[int] = None,
 2783        # Ignore any unknown arguments
 2784        **_kwargs: Any,
 2785    ):
 2786        if adminPayload is not None:
 2787            self.adminPayload = _ContestPracticeDetailsPayload_adminPayload(
 2788                **adminPayload)
 2789        else:
 2790            self.adminPayload = None
 2791        self.clarifications = [_Clarification(**v) for v in clarifications]
 2792        self.contest = _ContestPublicDetails(**contest)
 2793        self.contestAdmin = contestAdmin
 2794        if original is not None:
 2795            self.original = _ContestPracticeDetailsPayload_original(**original)
 2796        else:
 2797            self.original = None
 2798        self.problems = [_NavbarProblemsetProblem(**v) for v in problems]
 2799        self.shouldShowFirstAssociatedIdentityRunWarning = shouldShowFirstAssociatedIdentityRunWarning
 2800        if submissionDeadline is not None:
 2801            self.submissionDeadline = datetime.datetime.fromtimestamp(
 2802                submissionDeadline)
 2803        else:
 2804            self.submissionDeadline = None
 2805
 2806
 2807@dataclasses.dataclass
 2808class _ContestPracticeDetailsPayload_adminPayload:
 2809    """_ContestPracticeDetailsPayload_adminPayload"""
 2810    allRuns: Sequence['_Run']
 2811    users: Sequence['_ContestUser']
 2812
 2813    def __init__(
 2814        self,
 2815        *,
 2816        allRuns: Sequence[Dict[str, Any]],
 2817        users: Sequence[Dict[str, Any]],
 2818        # Ignore any unknown arguments
 2819        **_kwargs: Any,
 2820    ):
 2821        self.allRuns = [_Run(**v) for v in allRuns]
 2822        self.users = [_ContestUser(**v) for v in users]
 2823
 2824
 2825@dataclasses.dataclass
 2826class _ContestPracticeDetailsPayload_original:
 2827    """_ContestPracticeDetailsPayload_original"""
 2828    contest: _OmegaUp_DAO_VO_Contests
 2829    scoreboard: Optional['_Scoreboard']
 2830    scoreboardEvents: Optional[Sequence['_ScoreboardEvent']]
 2831
 2832    def __init__(
 2833        self,
 2834        *,
 2835        contest: Dict[str, Any],
 2836        scoreboard: Optional[Dict[str, Any]] = None,
 2837        scoreboardEvents: Optional[Sequence[Dict[str, Any]]] = None,
 2838        # Ignore any unknown arguments
 2839        **_kwargs: Any,
 2840    ):
 2841        self.contest = _OmegaUp_DAO_VO_Contests(**contest)
 2842        if scoreboard is not None:
 2843            self.scoreboard = _Scoreboard(**scoreboard)
 2844        else:
 2845            self.scoreboard = None
 2846        if scoreboardEvents is not None:
 2847            self.scoreboardEvents = [
 2848                _ScoreboardEvent(**v) for v in scoreboardEvents
 2849            ]
 2850        else:
 2851            self.scoreboardEvents = None
 2852
 2853
 2854@dataclasses.dataclass
 2855class _ContestPrintDetailsPayload:
 2856    """_ContestPrintDetailsPayload"""
 2857    contestTitle: str
 2858    problems: Dict[int, Optional['_ProblemDetails']]
 2859
 2860    def __init__(
 2861        self,
 2862        *,
 2863        contestTitle: str,
 2864        problems: Dict[int, Optional[Dict[str, Any]]],
 2865        # Ignore any unknown arguments
 2866        **_kwargs: Any,
 2867    ):
 2868        self.contestTitle = contestTitle
 2869        self.problems = {
 2870            k: _ProblemDetails(**v) if v is not None else None
 2871            for k, v in problems.items()
 2872        }
 2873
 2874
 2875@dataclasses.dataclass
 2876class _ContestPublicDetails:
 2877    """_ContestPublicDetails"""
 2878    admission_mode: str
 2879    alias: str
 2880    default_show_all_contestants_in_scoreboard: bool
 2881    description: str
 2882    director: str
 2883    feedback: str
 2884    finish_time: datetime.datetime
 2885    languages: str
 2886    partial_score: bool
 2887    penalty: int
 2888    penalty_calc_policy: str
 2889    penalty_type: str
 2890    points_decay_factor: float
 2891    problemset_id: int
 2892    rerun_id: Optional[int]
 2893    scoreboard: int
 2894    show_penalty: bool
 2895    show_scoreboard_after: bool
 2896    start_time: datetime.datetime
 2897    submissions_gap: int
 2898    title: str
 2899    user_registration_accepted: Optional[bool]
 2900    user_registration_answered: Optional[bool]
 2901    user_registration_requested: Optional[bool]
 2902    window_length: Optional[int]
 2903
 2904    def __init__(
 2905        self,
 2906        *,
 2907        admission_mode: str,
 2908        alias: str,
 2909        default_show_all_contestants_in_scoreboard: bool,
 2910        description: str,
 2911        director: str,
 2912        feedback: str,
 2913        finish_time: int,
 2914        languages: str,
 2915        partial_score: bool,
 2916        penalty: int,
 2917        penalty_calc_policy: str,
 2918        penalty_type: str,
 2919        points_decay_factor: float,
 2920        problemset_id: int,
 2921        scoreboard: int,
 2922        show_penalty: bool,
 2923        show_scoreboard_after: bool,
 2924        start_time: int,
 2925        submissions_gap: int,
 2926        title: str,
 2927        rerun_id: Optional[int] = None,
 2928        user_registration_accepted: Optional[bool] = None,
 2929        user_registration_answered: Optional[bool] = None,
 2930        user_registration_requested: Optional[bool] = None,
 2931        window_length: Optional[int] = None,
 2932        # Ignore any unknown arguments
 2933        **_kwargs: Any,
 2934    ):
 2935        self.admission_mode = admission_mode
 2936        self.alias = alias
 2937        self.default_show_all_contestants_in_scoreboard = default_show_all_contestants_in_scoreboard
 2938        self.description = description
 2939        self.director = director
 2940        self.feedback = feedback
 2941        self.finish_time = datetime.datetime.fromtimestamp(finish_time)
 2942        self.languages = languages
 2943        self.partial_score = partial_score
 2944        self.penalty = penalty
 2945        self.penalty_calc_policy = penalty_calc_policy
 2946        self.penalty_type = penalty_type
 2947        self.points_decay_factor = points_decay_factor
 2948        self.problemset_id = problemset_id
 2949        if rerun_id is not None:
 2950            self.rerun_id = rerun_id
 2951        else:
 2952            self.rerun_id = None
 2953        self.scoreboard = scoreboard
 2954        self.show_penalty = show_penalty
 2955        self.show_scoreboard_after = show_scoreboard_after
 2956        self.start_time = datetime.datetime.fromtimestamp(start_time)
 2957        self.submissions_gap = submissions_gap
 2958        self.title = title
 2959        if user_registration_accepted is not None:
 2960            self.user_registration_accepted = user_registration_accepted
 2961        else:
 2962            self.user_registration_accepted = None
 2963        if user_registration_answered is not None:
 2964            self.user_registration_answered = user_registration_answered
 2965        else:
 2966            self.user_registration_answered = None
 2967        if user_registration_requested is not None:
 2968            self.user_registration_requested = user_registration_requested
 2969        else:
 2970            self.user_registration_requested = None
 2971        if window_length is not None:
 2972            self.window_length = window_length
 2973        else:
 2974            self.window_length = None
 2975
 2976
 2977@dataclasses.dataclass
 2978class _ContestReport:
 2979    """_ContestReport"""
 2980    country: Optional[str]
 2981    is_invited: bool
 2982    name: Optional[str]
 2983    place: Optional[int]
 2984    problems: Sequence['_ScoreboardRankingProblem']
 2985    total: '_ContestReport_total'
 2986    username: str
 2987
 2988    def __init__(
 2989        self,
 2990        *,
 2991        is_invited: bool,
 2992        problems: Sequence[Dict[str, Any]],
 2993        total: Dict[str, Any],
 2994        username: str,
 2995        country: Optional[str] = None,
 2996        name: Optional[str] = None,
 2997        place: Optional[int] = None,
 2998        # Ignore any unknown arguments
 2999        **_kwargs: Any,
 3000    ):
 3001        if country is not None:
 3002            self.country = country
 3003        else:
 3004            self.country = None
 3005        self.is_invited = is_invited
 3006        if name is not None:
 3007            self.name = name
 3008        else:
 3009            self.name = None
 3010        if place is not None:
 3011            self.place = place
 3012        else:
 3013            self.place = None
 3014        self.problems = [_ScoreboardRankingProblem(**v) for v in problems]
 3015        self.total = _ContestReport_total(**total)
 3016        self.username = username
 3017
 3018
 3019@dataclasses.dataclass
 3020class _ContestReportDetailsPayload:
 3021    """_ContestReportDetailsPayload"""
 3022    contestAlias: str
 3023    contestReport: Sequence['_ContestReport']
 3024
 3025    def __init__(
 3026        self,
 3027        *,
 3028        contestAlias: str,
 3029        contestReport: Sequence[Dict[str, Any]],
 3030        # Ignore any unknown arguments
 3031        **_kwargs: Any,
 3032    ):
 3033        self.contestAlias = contestAlias
 3034        self.contestReport = [_ContestReport(**v) for v in contestReport]
 3035
 3036
 3037@dataclasses.dataclass
 3038class _ContestReport_total:
 3039    """_ContestReport_total"""
 3040    penalty: float
 3041    points: float
 3042
 3043    def __init__(
 3044        self,
 3045        *,
 3046        penalty: float,
 3047        points: float,
 3048        # Ignore any unknown arguments
 3049        **_kwargs: Any,
 3050    ):
 3051        self.penalty = penalty
 3052        self.points = points
 3053
 3054
 3055@dataclasses.dataclass
 3056class _ContestRequest:
 3057    """_ContestRequest"""
 3058    accepted: Optional[bool]
 3059    admin: Optional['_ContestRequest_admin']
 3060    country: Optional[str]
 3061    last_update: Optional[datetime.datetime]
 3062    request_time: datetime.datetime
 3063    username: str
 3064
 3065    def __init__(
 3066        self,
 3067        *,
 3068        request_time: int,
 3069        username: str,
 3070        accepted: Optional[bool] = None,
 3071        admin: Optional[Dict[str, Any]] = None,
 3072        country: Optional[str] = None,
 3073        last_update: Optional[int] = None,
 3074        # Ignore any unknown arguments
 3075        **_kwargs: Any,
 3076    ):
 3077        if accepted is not None:
 3078            self.accepted = accepted
 3079        else:
 3080            self.accepted = None
 3081        if admin is not None:
 3082            self.admin = _ContestRequest_admin(**admin)
 3083        else:
 3084            self.admin = None
 3085        if country is not None:
 3086            self.country = country
 3087        else:
 3088            self.country = None
 3089        if last_update is not None:
 3090            self.last_update = datetime.datetime.fromtimestamp(last_update)
 3091        else:
 3092            self.last_update = None
 3093        self.request_time = datetime.datetime.fromtimestamp(request_time)
 3094        self.username = username
 3095
 3096
 3097@dataclasses.dataclass
 3098class _ContestRequest_admin:
 3099    """_ContestRequest_admin"""
 3100    username: Optional[str]
 3101
 3102    def __init__(
 3103        self,
 3104        *,
 3105        username: Optional[str] = None,
 3106        # Ignore any unknown arguments
 3107        **_kwargs: Any,
 3108    ):
 3109        if username is not None:
 3110            self.username = username
 3111        else:
 3112            self.username = None
 3113
 3114
 3115@dataclasses.dataclass
 3116class _ContestScoreboardPayload:
 3117    """_ContestScoreboardPayload"""
 3118    contest: '_ContestDetails'
 3119    contestAdmin: bool
 3120    problems: Sequence['_NavbarProblemsetProblem']
 3121    scoreboard: '_Scoreboard'
 3122    scoreboardEvents: Sequence['_ScoreboardEvent']
 3123    scoreboardToken: Optional[str]
 3124
 3125    def __init__(
 3126        self,
 3127        *,
 3128        contest: Dict[str, Any],
 3129        contestAdmin: bool,
 3130        problems: Sequence[Dict[str, Any]],
 3131        scoreboard: Dict[str, Any],
 3132        scoreboardEvents: Sequence[Dict[str, Any]],
 3133        scoreboardToken: Optional[str] = None,
 3134        # Ignore any unknown arguments
 3135        **_kwargs: Any,
 3136    ):
 3137        self.contest = _ContestDetails(**contest)
 3138        self.contestAdmin = contestAdmin
 3139        self.problems = [_NavbarProblemsetProblem(**v) for v in problems]
 3140        self.scoreboard = _Scoreboard(**scoreboard)
 3141        self.scoreboardEvents = [
 3142            _ScoreboardEvent(**v) for v in scoreboardEvents
 3143        ]
 3144        if scoreboardToken is not None:
 3145            self.scoreboardToken = scoreboardToken
 3146        else:
 3147            self.scoreboardToken = None
 3148
 3149
 3150@dataclasses.dataclass
 3151class _ContestUser:
 3152    """_ContestUser"""
 3153    access_time: Optional[datetime.datetime]
 3154    country_id: Optional[str]
 3155    end_time: Optional[datetime.datetime]
 3156    is_owner: Optional[int]
 3157    username: str
 3158
 3159    def __init__(
 3160        self,
 3161        *,
 3162        username: str,
 3163        access_time: Optional[int] = None,
 3164        country_id: Optional[str] = None,
 3165        end_time: Optional[int] = None,
 3166        is_owner: Optional[int] = None,
 3167        # Ignore any unknown arguments
 3168        **_kwargs: Any,
 3169    ):
 3170        if access_time is not None:
 3171            self.access_time = datetime.datetime.fromtimestamp(access_time)
 3172        else:
 3173            self.access_time = None
 3174        if country_id is not None:
 3175            self.country_id = country_id
 3176        else:
 3177            self.country_id = None
 3178        if end_time is not None:
 3179            self.end_time = datetime.datetime.fromtimestamp(end_time)
 3180        else:
 3181            self.end_time = None
 3182        if is_owner is not None:
 3183            self.is_owner = is_owner
 3184        else:
 3185            self.is_owner = None
 3186        self.username = username
 3187
 3188
 3189@dataclasses.dataclass
 3190class _ContestVirtualDetailsPayload:
 3191    """_ContestVirtualDetailsPayload"""
 3192    contest: '_ContestPublicDetails'
 3193
 3194    def __init__(
 3195        self,
 3196        *,
 3197        contest: Dict[str, Any],
 3198        # Ignore any unknown arguments
 3199        **_kwargs: Any,
 3200    ):
 3201        self.contest = _ContestPublicDetails(**contest)
 3202
 3203
 3204@dataclasses.dataclass
 3205class _Contestant:
 3206    """_Contestant"""
 3207    country: Optional[str]
 3208    email: Optional[str]
 3209    gender: Optional[str]
 3210    name: Optional[str]
 3211    school: Optional[str]
 3212    state: Optional[str]
 3213    username: str
 3214
 3215    def __init__(
 3216        self,
 3217        *,
 3218        username: str,
 3219        country: Optional[str] = None,
 3220        email: Optional[str] = None,
 3221        gender: Optional[str] = None,
 3222        name: Optional[str] = None,
 3223        school: Optional[str] = None,
 3224        state: Optional[str] = None,
 3225        # Ignore any unknown arguments
 3226        **_kwargs: Any,
 3227    ):
 3228        if country is not None:
 3229            self.country = country
 3230        else:
 3231            self.country = None
 3232        if email is not None:
 3233            self.email = email
 3234        else:
 3235            self.email = None
 3236        if gender is not None:
 3237            self.gender = gender
 3238        else:
 3239            self.gender = None
 3240        if name is not None:
 3241            self.name = name
 3242        else:
 3243            self.name = None
 3244        if school is not None:
 3245            self.school = school
 3246        else:
 3247            self.school = None
 3248        if state is not None:
 3249            self.state = state
 3250        else:
 3251            self.state = None
 3252        self.username = username
 3253
 3254
 3255@dataclasses.dataclass
 3256class _Course:
 3257    """_Course"""
 3258    acl_id: Optional[int]
 3259    admission_mode: str
 3260    alias: str
 3261    archived: bool
 3262    course_id: int
 3263    description: str
 3264    finish_time: Optional[datetime.datetime]
 3265    group_id: Optional[int]
 3266    languages: Optional[str]
 3267    level: Optional[str]
 3268    minimum_progress_for_certificate: Optional[int]
 3269    name: str
 3270    needs_basic_information: bool
 3271    objective: Optional[str]
 3272    requests_user_information: str
 3273    school_id: Optional[int]
 3274    show_scoreboard: bool
 3275    start_time: datetime.datetime
 3276
 3277    def __init__(
 3278        self,
 3279        *,
 3280        admission_mode: str,
 3281        alias: str,
 3282        archived: bool,
 3283        course_id: int,
 3284        description: str,
 3285        name: str,
 3286        needs_basic_information: bool,
 3287        requests_user_information: str,
 3288        show_scoreboard: bool,
 3289        start_time: int,
 3290        acl_id: Optional[int] = None,
 3291        finish_time: Optional[int] = None,
 3292        group_id: Optional[int] = None,
 3293        languages: Optional[str] = None,
 3294        level: Optional[str] = None,
 3295        minimum_progress_for_certificate: Optional[int] = None,
 3296        objective: Optional[str] = None,
 3297        school_id: Optional[int] = None,
 3298        # Ignore any unknown arguments
 3299        **_kwargs: Any,
 3300    ):
 3301        if acl_id is not None:
 3302            self.acl_id = acl_id
 3303        else:
 3304            self.acl_id = None
 3305        self.admission_mode = admission_mode
 3306        self.alias = alias
 3307        self.archived = archived
 3308        self.course_id = course_id
 3309        self.description = description
 3310        if finish_time is not None:
 3311            self.finish_time = datetime.datetime.fromtimestamp(finish_time)
 3312        else:
 3313            self.finish_time = None
 3314        if group_id is not None:
 3315            self.group_id = group_id
 3316        else:
 3317            self.group_id = None
 3318        if languages is not None:
 3319            self.languages = languages
 3320        else:
 3321            self.languages = None
 3322        if level is not None:
 3323            self.level = level
 3324        else:
 3325            self.level = None
 3326        if minimum_progress_for_certificate is not None:
 3327            self.minimum_progress_for_certificate = minimum_progress_for_certificate
 3328        else:
 3329            self.minimum_progress_for_certificate = None
 3330        self.name = name
 3331        self.needs_basic_information = needs_basic_information
 3332        if objective is not None:
 3333            self.objective = objective
 3334        else:
 3335            self.objective = None
 3336        self.requests_user_information = requests_user_information
 3337        if school_id is not None:
 3338            self.school_id = school_id
 3339        else:
 3340            self.school_id = None
 3341        self.show_scoreboard = show_scoreboard
 3342        self.start_time = datetime.datetime.fromtimestamp(start_time)
 3343
 3344
 3345@dataclasses.dataclass
 3346class _CourseAdmin:
 3347    """_CourseAdmin"""
 3348    role: str
 3349    username: str
 3350
 3351    def __init__(
 3352        self,
 3353        *,
 3354        role: str,
 3355        username: str,
 3356        # Ignore any unknown arguments
 3357        **_kwargs: Any,
 3358    ):
 3359        self.role = role
 3360        self.username = username
 3361
 3362
 3363@dataclasses.dataclass
 3364class _CourseAssignment:
 3365    """_CourseAssignment"""
 3366    alias: str
 3367    assignment_type: str
 3368    description: str
 3369    finish_time: Optional[datetime.datetime]
 3370    has_runs: bool
 3371    max_points: float
 3372    name: str
 3373    opened: bool
 3374    order: int
 3375    problemCount: int
 3376    problemset_id: int
 3377    publish_time_delay: Optional[int]
 3378    scoreboard_url: str
 3379    scoreboard_url_admin: str
 3380    start_time: datetime.datetime
 3381
 3382    def __init__(
 3383        self,
 3384        *,
 3385        alias: str,
 3386        assignment_type: str,
 3387        description: str,
 3388        has_runs: bool,
 3389        max_points: float,
 3390        name: str,
 3391        opened: bool,
 3392        order: int,
 3393        problemCount: int,
 3394        problemset_id: int,
 3395        scoreboard_url: str,
 3396        scoreboard_url_admin: str,
 3397        start_time: int,
 3398        finish_time: Optional[int] = None,
 3399        publish_time_delay: Optional[int] = None,
 3400        # Ignore any unknown arguments
 3401        **_kwargs: Any,
 3402    ):
 3403        self.alias = alias
 3404        self.assignment_type = assignment_type
 3405        self.description = description
 3406        if finish_time is not None:
 3407            self.finish_time = datetime.datetime.fromtimestamp(finish_time)
 3408        else:
 3409            self.finish_time = None
 3410        self.has_runs = has_runs
 3411        self.max_points = max_points
 3412        self.name = name
 3413        self.opened = opened
 3414        self.order = order
 3415        self.problemCount = problemCount
 3416        self.problemset_id = problemset_id
 3417        if publish_time_delay is not None:
 3418            self.publish_time_delay = publish_time_delay
 3419        else:
 3420            self.publish_time_delay = None
 3421        self.scoreboard_url = scoreboard_url
 3422        self.scoreboard_url_admin = scoreboard_url_admin
 3423        self.start_time = datetime.datetime.fromtimestamp(start_time)
 3424
 3425
 3426@dataclasses.dataclass
 3427class _CourseCardEnrolled:
 3428    """_CourseCardEnrolled"""
 3429    alias: str
 3430    name: str
 3431    progress: float
 3432    school_name: Optional[str]
 3433
 3434    def __init__(
 3435        self,
 3436        *,
 3437        alias: str,
 3438        name: str,
 3439        progress: float,
 3440        school_name: Optional[str] = None,
 3441        # Ignore any unknown arguments
 3442        **_kwargs: Any,
 3443    ):
 3444        self.alias = alias
 3445        self.name = name
 3446        self.progress = progress
 3447        if school_name is not None:
 3448            self.school_name = school_name
 3449        else:
 3450            self.school_name = None
 3451
 3452
 3453@dataclasses.dataclass
 3454class _CourseCardFinished:
 3455    """_CourseCardFinished"""
 3456    alias: str
 3457    name: str
 3458
 3459    def __init__(
 3460        self,
 3461        *,
 3462        alias: str,
 3463        name: str,
 3464        # Ignore any unknown arguments
 3465        **_kwargs: Any,
 3466    ):
 3467        self.alias = alias
 3468        self.name = name
 3469
 3470
 3471@dataclasses.dataclass
 3472class _CourseCardPublic:
 3473    """_CourseCardPublic"""
 3474    alias: str
 3475    alreadyStarted: bool
 3476    lessonCount: int
 3477    level: Optional[str]
 3478    name: str
 3479    school_name: Optional[str]
 3480    studentCount: int
 3481
 3482    def __init__(
 3483        self,
 3484        *,
 3485        alias: str,
 3486        alreadyStarted: bool,
 3487        lessonCount: int,
 3488        name: str,
 3489        studentCount: int,
 3490        level: Optional[str] = None,
 3491        school_name: Optional[str] = None,
 3492        # Ignore any unknown arguments
 3493        **_kwargs: Any,
 3494    ):
 3495        self.alias = alias
 3496        self.alreadyStarted = alreadyStarted
 3497        self.lessonCount = lessonCount
 3498        if level is not None:
 3499            self.level = level
 3500        else:
 3501            self.level = None
 3502        self.name = name
 3503        if school_name is not None:
 3504            self.school_name = school_name
 3505        else:
 3506            self.school_name = None
 3507        self.studentCount = studentCount
 3508
 3509
 3510@dataclasses.dataclass
 3511class _CourseClarificationsPayload:
 3512    """_CourseClarificationsPayload"""
 3513    clarifications: Sequence['_Clarification']
 3514    length: int
 3515    page: int
 3516    pagerItems: Sequence['_PageItem']
 3517
 3518    def __init__(
 3519        self,
 3520        *,
 3521        clarifications: Sequence[Dict[str, Any]],
 3522        length: int,
 3523        page: int,
 3524        pagerItems: Sequence[Dict[str, Any]],
 3525        # Ignore any unknown arguments
 3526        **_kwargs: Any,
 3527    ):
 3528        self.clarifications = [_Clarification(**v) for v in clarifications]
 3529        self.length = length
 3530        self.page = page
 3531        self.pagerItems = [_PageItem(**v) for v in pagerItems]
 3532
 3533
 3534@dataclasses.dataclass
 3535class _CourseCloneDetailsPayload:
 3536    """_CourseCloneDetailsPayload"""
 3537    creator: '_CourseCloneDetailsPayload_creator'
 3538    details: '_CourseDetails'
 3539    token: Optional[str]
 3540
 3541    def __init__(
 3542        self,
 3543        *,
 3544        creator: Dict[str, Any],
 3545        details: Dict[str, Any],
 3546        token: Optional[str] = None,
 3547        # Ignore any unknown arguments
 3548        **_kwargs: Any,
 3549    ):
 3550        self.creator = _CourseCloneDetailsPayload_creator(**creator)
 3551        self.details = _CourseDetails(**details)
 3552        if token is not None:
 3553            self.token = token
 3554        else:
 3555            self.token = None
 3556
 3557
 3558@dataclasses.dataclass
 3559class _CourseCloneDetailsPayload_creator:
 3560    """_CourseCloneDetailsPayload_creator"""
 3561    classname: str
 3562    username: str
 3563
 3564    def __init__(
 3565        self,
 3566        *,
 3567        classname: str,
 3568        username: str,
 3569        # Ignore any unknown arguments
 3570        **_kwargs: Any,
 3571    ):
 3572        self.classname = classname
 3573        self.username = username
 3574
 3575
 3576@dataclasses.dataclass
 3577class _CourseDetails:
 3578    """_CourseDetails"""
 3579    admission_mode: str
 3580    alias: str
 3581    archived: bool
 3582    assignments: Sequence['_CourseAssignment']
 3583    clarifications: Sequence['_Clarification']
 3584    description: str
 3585    finish_time: Optional[datetime.datetime]
 3586    is_admin: bool
 3587    is_curator: bool
 3588    languages: Optional[Sequence[str]]
 3589    level: Optional[str]
 3590    name: str
 3591    needs_basic_information: bool
 3592    objective: Optional[str]
 3593    requests_user_information: str
 3594    school_id: Optional[int]
 3595    school_name: Optional[str]
 3596    show_scoreboard: bool
 3597    start_time: datetime.datetime
 3598    student_count: Optional[int]
 3599    unlimited_duration: bool
 3600
 3601    def __init__(
 3602        self,
 3603        *,
 3604        admission_mode: str,
 3605        alias: str,
 3606        archived: bool,
 3607        assignments: Sequence[Dict[str, Any]],
 3608        clarifications: Sequence[Dict[str, Any]],
 3609        description: str,
 3610        is_admin: bool,
 3611        is_curator: bool,
 3612        name: str,
 3613        needs_basic_information: bool,
 3614        requests_user_information: str,
 3615        show_scoreboard: bool,
 3616        start_time: int,
 3617        unlimited_duration: bool,
 3618        finish_time: Optional[int] = None,
 3619        languages: Optional[Sequence[str]] = None,
 3620        level: Optional[str] = None,
 3621        objective: Optional[str] = None,
 3622        school_id: Optional[int] = None,
 3623        school_name: Optional[str] = None,
 3624        student_count: Optional[int] = None,
 3625        # Ignore any unknown arguments
 3626        **_kwargs: Any,
 3627    ):
 3628        self.admission_mode = admission_mode
 3629        self.alias = alias
 3630        self.archived = archived
 3631        self.assignments = [_CourseAssignment(**v) for v in assignments]
 3632        self.clarifications = [_Clarification(**v) for v in clarifications]
 3633        self.description = description
 3634        if finish_time is not None:
 3635            self.finish_time = datetime.datetime.fromtimestamp(finish_time)
 3636        else:
 3637            self.finish_time = None
 3638        self.is_admin = is_admin
 3639        self.is_curator = is_curator
 3640        if languages is not None:
 3641            self.languages = [v for v in languages]
 3642        else:
 3643            self.languages = None
 3644        if level is not None:
 3645            self.level = level
 3646        else:
 3647            self.level = None
 3648        self.name = name
 3649        self.needs_basic_information = needs_basic_information
 3650        if objective is not None:
 3651            self.objective = objective
 3652        else:
 3653            self.objective = None
 3654        self.requests_user_information = requests_user_information
 3655        if school_id is not None:
 3656            self.school_id = school_id
 3657        else:
 3658            self.school_id = None
 3659        if school_name is not None:
 3660            self.school_name = school_name
 3661        else:
 3662            self.school_name = None
 3663        self.show_scoreboard = show_scoreboard
 3664        self.start_time = datetime.datetime.fromtimestamp(start_time)
 3665        if student_count is not None:
 3666            self.student_count = student_count
 3667        else:
 3668            self.student_count = None
 3669        self.unlimited_duration = unlimited_duration
 3670
 3671
 3672@dataclasses.dataclass
 3673class _CourseDetailsPayload:
 3674    """_CourseDetailsPayload"""
 3675    details: '_CourseDetails'
 3676    progress: Optional[Dict[str, '_Progress']]
 3677
 3678    def __init__(
 3679        self,
 3680        *,
 3681        details: Dict[str, Any],
 3682        progress: Optional[Dict[str, Dict[str, Any]]] = None,
 3683        # Ignore any unknown arguments
 3684        **_kwargs: Any,
 3685    ):
 3686        self.details = _CourseDetails(**details)
 3687        if progress is not None:
 3688            self.progress = {k: _Progress(**v) for k, v in progress.items()}
 3689        else:
 3690            self.progress = None
 3691
 3692
 3693@dataclasses.dataclass
 3694class _CourseEditPayload:
 3695    """_CourseEditPayload"""
 3696    admins: Sequence['_CourseAdmin']
 3697    allLanguages: Dict[str, str]
 3698    assignmentProblems: Sequence['_ProblemsetProblem']
 3699    course: '_CourseDetails'
 3700    groupsAdmins: Sequence['_CourseGroupAdmin']
 3701    groupsTeachingAssistants: Sequence['_CourseGroupAdmin']
 3702    identityRequests: Sequence['_IdentityRequest']
 3703    selectedAssignment: Optional['_CourseAssignment']
 3704    students: Sequence['_CourseStudent']
 3705    tags: Sequence[str]
 3706    teachingAssistants: Sequence['_CourseAdmin']
 3707
 3708    def __init__(
 3709        self,
 3710        *,
 3711        admins: Sequence[Dict[str, Any]],
 3712        allLanguages: Dict[str, str],
 3713        assignmentProblems: Sequence[Dict[str, Any]],
 3714        course: Dict[str, Any],
 3715        groupsAdmins: Sequence[Dict[str, Any]],
 3716        groupsTeachingAssistants: Sequence[Dict[str, Any]],
 3717        identityRequests: Sequence[Dict[str, Any]],
 3718        students: Sequence[Dict[str, Any]],
 3719        tags: Sequence[str],
 3720        teachingAssistants: Sequence[Dict[str, Any]],
 3721        selectedAssignment: Optional[Dict[str, Any]] = None,
 3722        # Ignore any unknown arguments
 3723        **_kwargs: Any,
 3724    ):
 3725        self.admins = [_CourseAdmin(**v) for v in admins]
 3726        self.allLanguages = {k: v for k, v in allLanguages.items()}
 3727        self.assignmentProblems = [
 3728            _ProblemsetProblem(**v) for v in assignmentProblems
 3729        ]
 3730        self.course = _CourseDetails(**course)
 3731        self.groupsAdmins = [_CourseGroupAdmin(**v) for v in groupsAdmins]
 3732        self.groupsTeachingAssistants = [
 3733            _CourseGroupAdmin(**v) for v in groupsTeachingAssistants
 3734        ]
 3735        self.identityRequests = [
 3736            _IdentityRequest(**v) for v in identityRequests
 3737        ]
 3738        if selectedAssignment is not None:
 3739            self.selectedAssignment = _CourseAssignment(**selectedAssignment)
 3740        else:
 3741            self.selectedAssignment = None
 3742        self.students = [_CourseStudent(**v) for v in students]
 3743        self.tags = [v for v in tags]
 3744        self.teachingAssistants = [
 3745            _CourseAdmin(**v) for v in teachingAssistants
 3746        ]
 3747
 3748
 3749@dataclasses.dataclass
 3750class _CourseGroupAdmin:
 3751    """_CourseGroupAdmin"""
 3752    alias: str
 3753    name: str
 3754    role: str
 3755
 3756    def __init__(
 3757        self,
 3758        *,
 3759        alias: str,
 3760        name: str,
 3761        role: str,
 3762        # Ignore any unknown arguments
 3763        **_kwargs: Any,
 3764    ):
 3765        self.alias = alias
 3766        self.name = name
 3767        self.role = role
 3768
 3769
 3770@dataclasses.dataclass
 3771class _CourseListMinePayload:
 3772    """_CourseListMinePayload"""
 3773    courses: '_AdminCourses'
 3774
 3775    def __init__(
 3776        self,
 3777        *,
 3778        courses: Dict[str, Any],
 3779        # Ignore any unknown arguments
 3780        **_kwargs: Any,
 3781    ):
 3782        self.courses = _AdminCourses(**courses)
 3783
 3784
 3785@dataclasses.dataclass
 3786class _CourseNewPayload:
 3787    """_CourseNewPayload"""
 3788    is_admin: bool
 3789    is_curator: bool
 3790    languages: Dict[str, str]
 3791
 3792    def __init__(
 3793        self,
 3794        *,
 3795        is_admin: bool,
 3796        is_curator: bool,
 3797        languages: Dict[str, str],
 3798        # Ignore any unknown arguments
 3799        **_kwargs: Any,
 3800    ):
 3801        self.is_admin = is_admin
 3802        self.is_curator = is_curator
 3803        self.languages = {k: v for k, v in languages.items()}
 3804
 3805
 3806@dataclasses.dataclass
 3807class _CourseProblem:
 3808    """_CourseProblem"""
 3809    accepted: int
 3810    alias: str
 3811    commit: str
 3812    difficulty: float
 3813    languages: str
 3814    letter: str
 3815    order: int
 3816    points: float
 3817    runs: Sequence['_CourseRun']
 3818    submissions: int
 3819    title: str
 3820    version: str
 3821    visibility: int
 3822    visits: int
 3823
 3824    def __init__(
 3825        self,
 3826        *,
 3827        accepted: int,
 3828        alias: str,
 3829        commit: str,
 3830        difficulty: float,
 3831        languages: str,
 3832        letter: str,
 3833        order: int,
 3834        points: float,
 3835        runs: Sequence[Dict[str, Any]],
 3836        submissions: int,
 3837        title: str,
 3838        version: str,
 3839        visibility: int,
 3840        visits: int,
 3841        # Ignore any unknown arguments
 3842        **_kwargs: Any,
 3843    ):
 3844        self.accepted = accepted
 3845        self.alias = alias
 3846        self.commit = commit
 3847        self.difficulty = difficulty
 3848        self.languages = languages
 3849        self.letter = letter
 3850        self.order = order
 3851        self.points = points
 3852        self.runs = [_CourseRun(**v) for v in runs]
 3853        self.submissions = submissions
 3854        self.title = title
 3855        self.version = version
 3856        self.visibility = visibility
 3857        self.visits = visits
 3858
 3859
 3860@dataclasses.dataclass
 3861class _CourseProblemStatistics:
 3862    """_CourseProblemStatistics"""
 3863    assignment_alias: str
 3864    average: float
 3865    avg_runs: float
 3866    completed_score_percentage: float
 3867    high_score_percentage: float
 3868    low_score_percentage: float
 3869    max_points: float
 3870    maximum: float
 3871    minimum: float
 3872    problem_alias: str
 3873    variance: float
 3874
 3875    def __init__(
 3876        self,
 3877        *,
 3878        assignment_alias: str,
 3879        average: float,
 3880        avg_runs: float,
 3881        completed_score_percentage: float,
 3882        high_score_percentage: float,
 3883        low_score_percentage: float,
 3884        max_points: float,
 3885        maximum: float,
 3886        minimum: float,
 3887        problem_alias: str,
 3888        variance: float,
 3889        # Ignore any unknown arguments
 3890        **_kwargs: Any,
 3891    ):
 3892        self.assignment_alias = assignment_alias
 3893        self.average = average
 3894        self.avg_runs = avg_runs
 3895        self.completed_score_percentage = completed_score_percentage
 3896        self.high_score_percentage = high_score_percentage
 3897        self.low_score_percentage = low_score_percentage
 3898        self.max_points = max_points
 3899        self.maximum = maximum
 3900        self.minimum = minimum
 3901        self.problem_alias = problem_alias
 3902        self.variance = variance
 3903
 3904
 3905@dataclasses.dataclass
 3906class _CourseProblemTried:
 3907    """_CourseProblemTried"""
 3908    alias: str
 3909    title: str
 3910    username: str
 3911
 3912    def __init__(
 3913        self,
 3914        *,
 3915        alias: str,
 3916        title: str,
 3917        username: str,
 3918        # Ignore any unknown arguments
 3919        **_kwargs: Any,
 3920    ):
 3921        self.alias = alias
 3922        self.title = title
 3923        self.username = username
 3924
 3925
 3926@dataclasses.dataclass
 3927class _CourseProblemVerdict:
 3928    """_CourseProblemVerdict"""
 3929    assignment_alias: str
 3930    problem_alias: str
 3931    problem_id: int
 3932    runs: int
 3933    verdict: Optional[str]
 3934
 3935    def __init__(
 3936        self,
 3937        *,
 3938        assignment_alias: str,
 3939        problem_alias: str,
 3940        problem_id: int,
 3941        runs: int,
 3942        verdict: Optional[str] = None,
 3943        # Ignore any unknown arguments
 3944        **_kwargs: Any,
 3945    ):
 3946        self.assignment_alias = assignment_alias
 3947        self.problem_alias = problem_alias
 3948        self.problem_id = problem_id
 3949        self.runs = runs
 3950        if verdict is not None:
 3951            self.verdict = verdict
 3952        else:
 3953            self.verdict = None
 3954
 3955
 3956@dataclasses.dataclass
 3957class _CourseRun:
 3958    """_CourseRun"""
 3959    contest_score: Optional[float]
 3960    feedback: Optional['_SubmissionFeedback']
 3961    guid: str
 3962    language: str
 3963    memory: int
 3964    penalty: int
 3965    runtime: int
 3966    score: float
 3967    source: Optional[str]
 3968    status: str
 3969    submit_delay: int
 3970    time: datetime.datetime
 3971    verdict: str
 3972
 3973    def __init__(
 3974        self,
 3975        *,
 3976        guid: str,
 3977        language: str,
 3978        memory: int,
 3979        penalty: int,
 3980        runtime: int,
 3981        score: float,
 3982        status: str,
 3983        submit_delay: int,
 3984        time: int,
 3985        verdict: str,
 3986        contest_score: Optional[float] = None,
 3987        feedback: Optional[Dict[str, Any]] = None,
 3988        source: Optional[str] = None,
 3989        # Ignore any unknown arguments
 3990        **_kwargs: Any,
 3991    ):
 3992        if contest_score is not None:
 3993            self.contest_score = contest_score
 3994        else:
 3995            self.contest_score = None
 3996        if feedback is not None:
 3997            self.feedback = _SubmissionFeedback(**feedback)
 3998        else:
 3999            self.feedback = None
 4000        self.guid = guid
 4001        self.language = language
 4002        self.memory = memory
 4003        self.penalty = penalty
 4004        self.runtime = runtime
 4005        self.score = score
 4006        if source is not None:
 4007            self.source = source
 4008        else:
 4009            self.source = None
 4010        self.status = status
 4011        self.submit_delay = submit_delay
 4012        self.time = datetime.datetime.fromtimestamp(time)
 4013        self.verdict = verdict
 4014
 4015
 4016@dataclasses.dataclass
 4017class _CourseScoreboardPayload:
 4018    """_CourseScoreboardPayload"""
 4019    assignment: '_AssignmentDetails'
 4020    problems: Sequence['_NavbarProblemsetProblem']
 4021    scoreboard: '_Scoreboard'
 4022    scoreboardToken: Optional[str]
 4023
 4024    def __init__(
 4025        self,
 4026        *,
 4027        assignment: Dict[str, Any],
 4028        problems: Sequence[Dict[str, Any]],
 4029        scoreboard: Dict[str, Any],
 4030        scoreboardToken: Optional[str] = None,
 4031        # Ignore any unknown arguments
 4032        **_kwargs: Any,
 4033    ):
 4034        self.assignment = _AssignmentDetails(**assignment)
 4035        self.problems = [_NavbarProblemsetProblem(**v) for v in problems]
 4036        self.scoreboard = _Scoreboard(**scoreboard)
 4037        if scoreboardToken is not None:
 4038            self.scoreboardToken = scoreboardToken
 4039        else:
 4040            self.scoreboardToken = None
 4041
 4042
 4043@dataclasses.dataclass
 4044class _CourseStatisticsPayload:
 4045    """_CourseStatisticsPayload"""
 4046    course: '_CourseDetails'
 4047    problemStats: Sequence['_CourseProblemStatistics']
 4048    verdicts: Sequence['_CourseProblemVerdict']
 4049
 4050    def __init__(
 4051        self,
 4052        *,
 4053        course: Dict[str, Any],
 4054        problemStats: Sequence[Dict[str, Any]],
 4055        verdicts: Sequence[Dict[str, Any]],
 4056        # Ignore any unknown arguments
 4057        **_kwargs: Any,
 4058    ):
 4059        self.course = _CourseDetails(**course)
 4060        self.problemStats = [
 4061            _CourseProblemStatistics(**v) for v in problemStats
 4062        ]
 4063        self.verdicts = [_CourseProblemVerdict(**v) for v in verdicts]
 4064
 4065
 4066@dataclasses.dataclass
 4067class _CourseStudent:
 4068    """_CourseStudent"""
 4069    name: Optional[str]
 4070    username: str
 4071
 4072    def __init__(
 4073        self,
 4074        *,
 4075        username: str,
 4076        name: Optional[str] = None,
 4077        # Ignore any unknown arguments
 4078        **_kwargs: Any,
 4079    ):
 4080        if name is not None:
 4081            self.name = name
 4082        else:
 4083            self.name = None
 4084        self.username = username
 4085
 4086
 4087@dataclasses.dataclass
 4088class _CourseSubmissionsListPayload:
 4089    """_CourseSubmissionsListPayload"""
 4090    solvedProblems: Dict[str, Sequence['_CourseProblemTried']]
 4091    unsolvedProblems: Dict[str, Sequence['_CourseProblemTried']]
 4092
 4093    def __init__(
 4094        self,
 4095        *,
 4096        solvedProblems: Dict[str, Sequence[Dict[str, Any]]],
 4097        unsolvedProblems: Dict[str, Sequence[Dict[str, Any]]],
 4098        # Ignore any unknown arguments
 4099        **_kwargs: Any,
 4100    ):
 4101        self.solvedProblems = {
 4102            k: [_CourseProblemTried(**v) for v in v]
 4103            for k, v in solvedProblems.items()
 4104        }
 4105        self.unsolvedProblems = {
 4106            k: [_CourseProblemTried(**v) for v in v]
 4107            for k, v in unsolvedProblems.items()
 4108        }
 4109
 4110
 4111@dataclasses.dataclass
 4112class _CourseTabsPayload:
 4113    """_CourseTabsPayload"""
 4114    courses: '_CourseTabsPayload_courses'
 4115
 4116    def __init__(
 4117        self,
 4118        *,
 4119        courses: Dict[str, Any],
 4120        # Ignore any unknown arguments
 4121        **_kwargs: Any,
 4122    ):
 4123        self.courses = _CourseTabsPayload_courses(**courses)
 4124
 4125
 4126@dataclasses.dataclass
 4127class _CourseTabsPayload_courses:
 4128    """_CourseTabsPayload_courses"""
 4129    enrolled: Sequence['_CourseCardEnrolled']
 4130    finished: Sequence['_CourseCardFinished']
 4131    public: Sequence['_CourseCardPublic']
 4132
 4133    def __init__(
 4134        self,
 4135        *,
 4136        enrolled: Sequence[Dict[str, Any]],
 4137        finished: Sequence[Dict[str, Any]],
 4138        public: Sequence[Dict[str, Any]],
 4139        # Ignore any unknown arguments
 4140        **_kwargs: Any,
 4141    ):
 4142        self.enrolled = [_CourseCardEnrolled(**v) for v in enrolled]
 4143        self.finished = [_CourseCardFinished(**v) for v in finished]
 4144        self.public = [_CourseCardPublic(**v) for v in public]
 4145
 4146
 4147@dataclasses.dataclass
 4148class _CoursesByAccessMode:
 4149    """_CoursesByAccessMode"""
 4150    accessMode: str
 4151    activeTab: str
 4152    filteredCourses: '_CoursesByAccessMode_filteredCourses'
 4153
 4154    def __init__(
 4155        self,
 4156        *,
 4157        accessMode: str,
 4158        activeTab: str,
 4159        filteredCourses: Dict[str, Any],
 4160        # Ignore any unknown arguments
 4161        **_kwargs: Any,
 4162    ):
 4163        self.accessMode = accessMode
 4164        self.activeTab = activeTab
 4165        self.filteredCourses = _CoursesByAccessMode_filteredCourses(
 4166            **filteredCourses)
 4167
 4168
 4169@dataclasses.dataclass
 4170class _CoursesByAccessMode_filteredCourses:
 4171    """_CoursesByAccessMode_filteredCourses"""
 4172    current: '_CoursesByTimeType'
 4173    past: '_CoursesByTimeType'
 4174
 4175    def __init__(
 4176        self,
 4177        *,
 4178        current: Dict[str, Any],
 4179        past: Dict[str, Any],
 4180        # Ignore any unknown arguments
 4181        **_kwargs: Any,
 4182    ):
 4183        self.current = _CoursesByTimeType(**current)
 4184        self.past = _CoursesByTimeType(**past)
 4185
 4186
 4187@dataclasses.dataclass
 4188class _CoursesByTimeType:
 4189    """_CoursesByTimeType"""
 4190    courses: Sequence['_FilteredCourse']
 4191    timeType: str
 4192
 4193    def __init__(
 4194        self,
 4195        *,
 4196        courses: Sequence[Dict[str, Any]],
 4197        timeType: str,
 4198        # Ignore any unknown arguments
 4199        **_kwargs: Any,
 4200    ):
 4201        self.courses = [_FilteredCourse(**v) for v in courses]
 4202        self.timeType = timeType
 4203
 4204
 4205@dataclasses.dataclass
 4206class _CoursesList:
 4207    """_CoursesList"""
 4208    admin: Sequence['_FilteredCourse']
 4209    archived: Sequence['_FilteredCourse']
 4210    public: Sequence['_FilteredCourse']
 4211    student: Sequence['_FilteredCourse']
 4212    teachingAssistant: Sequence['_FilteredCourse']
 4213
 4214    def __init__(
 4215        self,
 4216        *,
 4217        admin: Sequence[Dict[str, Any]],
 4218        archived: Sequence[Dict[str, Any]],
 4219        public: Sequence[Dict[str, Any]],
 4220        student: Sequence[Dict[str, Any]],
 4221        teachingAssistant: Sequence[Dict[str, Any]],
 4222        # Ignore any unknown arguments
 4223        **_kwargs: Any,
 4224    ):
 4225        self.admin = [_FilteredCourse(**v) for v in admin]
 4226        self.archived = [_FilteredCourse(**v) for v in archived]
 4227        self.public = [_FilteredCourse(**v) for v in public]
 4228        self.student = [_FilteredCourse(**v) for v in student]
 4229        self.teachingAssistant = [
 4230            _FilteredCourse(**v) for v in teachingAssistant
 4231        ]
 4232
 4233
 4234@dataclasses.dataclass
 4235class _CurrentSession:
 4236    """_CurrentSession"""
 4237    apiTokenId: Optional[int]
 4238    associated_identities: Sequence['_AssociatedIdentity']
 4239    auth_token: Optional[str]
 4240    cacheKey: Optional[str]
 4241    classname: str
 4242    email: Optional[str]
 4243    identity: Optional[_OmegaUp_DAO_VO_Identities]
 4244    is_admin: bool
 4245    loginIdentity: Optional[_OmegaUp_DAO_VO_Identities]
 4246    user: Optional[_OmegaUp_DAO_VO_Users]
 4247    valid: bool
 4248
 4249    def __init__(
 4250        self,
 4251        *,
 4252        associated_identities: Sequence[Dict[str, Any]],
 4253        classname: str,
 4254        is_admin: bool,
 4255        valid: bool,
 4256        apiTokenId: Optional[int] = None,
 4257        auth_token: Optional[str] = None,
 4258        cacheKey: Optional[str] = None,
 4259        email: Optional[str] = None,
 4260        identity: Optional[Dict[str, Any]] = None,
 4261        loginIdentity: Optional[Dict[str, Any]] = None,
 4262        user: Optional[Dict[str, Any]] = None,
 4263        # Ignore any unknown arguments
 4264        **_kwargs: Any,
 4265    ):
 4266        if apiTokenId is not None:
 4267            self.apiTokenId = apiTokenId
 4268        else:
 4269            self.apiTokenId = None
 4270        self.associated_identities = [
 4271            _AssociatedIdentity(**v) for v in associated_identities
 4272        ]
 4273        if auth_token is not None:
 4274            self.auth_token = auth_token
 4275        else:
 4276            self.auth_token = None
 4277        if cacheKey is not None:
 4278            self.cacheKey = cacheKey
 4279        else:
 4280            self.cacheKey = None
 4281        self.classname = classname
 4282        if email is not None:
 4283            self.email = email
 4284        else:
 4285            self.email = None
 4286        if identity is not None:
 4287            self.identity = _OmegaUp_DAO_VO_Identities(**identity)
 4288        else:
 4289            self.identity = None
 4290        self.is_admin = is_admin
 4291        if loginIdentity is not None:
 4292            self.loginIdentity = _OmegaUp_DAO_VO_Identities(**loginIdentity)
 4293        else:
 4294            self.loginIdentity = None
 4295        if user is not None:
 4296            self.user = _OmegaUp_DAO_VO_Users(**user)
 4297        else:
 4298            self.user = None
 4299        self.valid = valid
 4300
 4301
 4302@dataclasses.dataclass
 4303class _EmailEditDetailsPayload:
 4304    """_EmailEditDetailsPayload"""
 4305    email: Optional[str]
 4306    profile: Optional['_UserProfileInfo']
 4307
 4308    def __init__(
 4309        self,
 4310        *,
 4311        email: Optional[str] = None,
 4312        profile: Optional[Dict[str, Any]] = None,
 4313        # Ignore any unknown arguments
 4314        **_kwargs: Any,
 4315    ):
 4316        if email is not None:
 4317            self.email = email
 4318        else:
 4319            self.email = None
 4320        if profile is not None:
 4321            self.profile = _UserProfileInfo(**profile)
 4322        else:
 4323            self.profile = None
 4324
 4325
 4326@dataclasses.dataclass
 4327class _Event:
 4328    """_Event"""
 4329    courseAlias: Optional[str]
 4330    courseName: Optional[str]
 4331    name: str
 4332    problem: Optional[str]
 4333
 4334    def __init__(
 4335        self,
 4336        *,
 4337        name: str,
 4338        courseAlias: Optional[str] = None,
 4339        courseName: Optional[str] = None,
 4340        problem: Optional[str] = None,
 4341        # Ignore any unknown arguments
 4342        **_kwargs: Any,
 4343    ):
 4344        if courseAlias is not None:
 4345            self.courseAlias = courseAlias
 4346        else:
 4347            self.courseAlias = None
 4348        if courseName is not None:
 4349            self.courseName = courseName
 4350        else:
 4351            self.courseName = None
 4352        self.name = name
 4353        if problem is not None:
 4354            self.problem = problem
 4355        else:
 4356            self.problem = None
 4357
 4358
 4359@dataclasses.dataclass
 4360class _Experiment:
 4361    """_Experiment"""
 4362    config: bool
 4363    hash: str
 4364    name: str
 4365
 4366    def __init__(
 4367        self,
 4368        *,
 4369        config: bool,
 4370        hash: str,
 4371        name: str,
 4372        # Ignore any unknown arguments
 4373        **_kwargs: Any,
 4374    ):
 4375        self.config = config
 4376        self.hash = hash
 4377        self.name = name
 4378
 4379
 4380@dataclasses.dataclass
 4381class _ExtraProfileDetails:
 4382    """_ExtraProfileDetails"""
 4383    badges: Sequence[str]
 4384    contests: Dict[str, '_UserProfileContests_value']
 4385    createdContests: Sequence['_Contest']
 4386    createdCourses: Sequence['_Course']
 4387    createdProblems: Sequence['_Problem']
 4388    hasPassword: bool
 4389    ownedBadges: Sequence['_Badge']
 4390    solvedProblems: Sequence['_Problem']
 4391    stats: Sequence['_UserProfileStats']
 4392    unsolvedProblems: Sequence['_Problem']
 4393
 4394    def __init__(
 4395        self,
 4396        *,
 4397        badges: Sequence[str],
 4398        contests: Dict[str, Dict[str, Any]],
 4399        createdContests: Sequence[Dict[str, Any]],
 4400        createdCourses: Sequence[Dict[str, Any]],
 4401        createdProblems: Sequence[Dict[str, Any]],
 4402        hasPassword: bool,
 4403        ownedBadges: Sequence[Dict[str, Any]],
 4404        solvedProblems: Sequence[Dict[str, Any]],
 4405        stats: Sequence[Dict[str, Any]],
 4406        unsolvedProblems: Sequence[Dict[str, Any]],
 4407        # Ignore any unknown arguments
 4408        **_kwargs: Any,
 4409    ):
 4410        self.badges = [v for v in badges]
 4411        self.contests = {
 4412            k: _UserProfileContests_value(**v)
 4413            for k, v in contests.items()
 4414        }
 4415        self.createdContests = [_Contest(**v) for v in createdContests]
 4416        self.createdCourses = [_Course(**v) for v in createdCourses]
 4417        self.createdProblems = [_Problem(**v) for v in createdProblems]
 4418        self.hasPassword = hasPassword
 4419        self.ownedBadges = [_Badge(**v) for v in ownedBadges]
 4420        self.solvedProblems = [_Problem(**v) for v in solvedProblems]
 4421        self.stats = [_UserProfileStats(**v) for v in stats]
 4422        self.unsolvedProblems = [_Problem(**v) for v in unsolvedProblems]
 4423
 4424
 4425@dataclasses.dataclass
 4426class _FilteredCourse:
 4427    """_FilteredCourse"""
 4428    accept_teacher: Optional[bool]
 4429    admission_mode: str
 4430    alias: str
 4431    assignments: Sequence['_CourseAssignment']
 4432    counts: Dict[str, int]
 4433    description: str
 4434    finish_time: Optional[datetime.datetime]
 4435    is_open: bool
 4436    name: str
 4437    progress: Optional[float]
 4438    school_name: Optional[str]
 4439    start_time: datetime.datetime
 4440
 4441    def __init__(
 4442        self,
 4443        *,
 4444        admission_mode: str,
 4445        alias: str,
 4446        assignments: Sequence[Dict[str, Any]],
 4447        counts: Dict[str, int],
 4448        description: str,
 4449        is_open: bool,
 4450        name: str,
 4451        start_time: int,
 4452        accept_teacher: Optional[bool] = None,
 4453        finish_time: Optional[int] = None,
 4454        progress: Optional[float] = None,
 4455        school_name: Optional[str] = None,
 4456        # Ignore any unknown arguments
 4457        **_kwargs: Any,
 4458    ):
 4459        if accept_teacher is not None:
 4460            self.accept_teacher = accept_teacher
 4461        else:
 4462            self.accept_teacher = None
 4463        self.admission_mode = admission_mode
 4464        self.alias = alias
 4465        self.assignments = [_CourseAssignment(**v) for v in assignments]
 4466        self.counts = {k: v for k, v in counts.items()}
 4467        self.description = description
 4468        if finish_time is not None:
 4469            self.finish_time = datetime.datetime.fromtimestamp(finish_time)
 4470        else:
 4471            self.finish_time = None
 4472        self.is_open = is_open
 4473        self.name = name
 4474        if progress is not None:
 4475            self.progress = progress
 4476        else:
 4477            self.progress = None
 4478        if school_name is not None:
 4479            self.school_name = school_name
 4480        else:
 4481            self.school_name = None
 4482        self.start_time = datetime.datetime.fromtimestamp(start_time)
 4483
 4484
 4485@dataclasses.dataclass
 4486class _GraderStatus:
 4487    """_GraderStatus"""
 4488    broadcaster_sockets: int
 4489    embedded_runner: bool
 4490    queue: '_GraderStatus_queue'
 4491    status: str
 4492
 4493    def __init__(
 4494        self,
 4495        *,
 4496        broadcaster_sockets: int,
 4497        embedded_runner: bool,
 4498        queue: Dict[str, Any],
 4499        status: str,
 4500        # Ignore any unknown arguments
 4501        **_kwargs: Any,
 4502    ):
 4503        self.broadcaster_sockets = broadcaster_sockets
 4504        self.embedded_runner = embedded_runner
 4505        self.queue = _GraderStatus_queue(**queue)
 4506        self.status = status
 4507
 4508
 4509@dataclasses.dataclass
 4510class _GraderStatus_queue:
 4511    """_GraderStatus_queue"""
 4512    run_queue_length: int
 4513    runner_queue_length: int
 4514    runners: Sequence[str]
 4515    running: Sequence['_GraderStatus_queue_running_entry']
 4516
 4517    def __init__(
 4518        self,
 4519        *,
 4520        run_queue_length: int,
 4521        runner_queue_length: int,
 4522        runners: Sequence[str],
 4523        running: Sequence[Dict[str, Any]],
 4524        # Ignore any unknown arguments
 4525        **_kwargs: Any,
 4526    ):
 4527        self.run_queue_length = run_queue_length
 4528        self.runner_queue_length = runner_queue_length
 4529        self.runners = [v for v in runners]
 4530        self.running = [
 4531            _GraderStatus_queue_running_entry(**v) for v in running
 4532        ]
 4533
 4534
 4535@dataclasses.dataclass
 4536class _GraderStatus_queue_running_entry:
 4537    """_GraderStatus_queue_running_entry"""
 4538    id: int
 4539    name: str
 4540
 4541    def __init__(
 4542        self,
 4543        *,
 4544        id: int,
 4545        name: str,
 4546        # Ignore any unknown arguments
 4547        **_kwargs: Any,
 4548    ):
 4549        self.id = id
 4550        self.name = name
 4551
 4552
 4553@dataclasses.dataclass
 4554class _Group:
 4555    """_Group"""
 4556    alias: str
 4557    create_time: datetime.datetime
 4558    description: Optional[str]
 4559    name: str
 4560
 4561    def __init__(
 4562        self,
 4563        *,
 4564        alias: str,
 4565        create_time: int,
 4566        name: str,
 4567        description: Optional[str] = None,
 4568        # Ignore any unknown arguments
 4569        **_kwargs: Any,
 4570    ):
 4571        self.alias = alias
 4572        self.create_time = datetime.datetime.fromtimestamp(create_time)
 4573        if description is not None:
 4574            self.description = description
 4575        else:
 4576            self.description = None
 4577        self.name = name
 4578
 4579
 4580@dataclasses.dataclass
 4581class _GroupEditPayload:
 4582    """_GroupEditPayload"""
 4583    countries: Sequence['_OmegaUp_DAO_VO_Countries']
 4584    groupAlias: str
 4585    groupDescription: Optional[str]
 4586    groupName: Optional[str]
 4587    identities: Sequence['_Identity']
 4588    isOrganizer: bool
 4589    scoreboards: Sequence['_GroupScoreboard']
 4590
 4591    def __init__(
 4592        self,
 4593        *,
 4594        countries: Sequence[Dict[str, Any]],
 4595        groupAlias: str,
 4596        identities: Sequence[Dict[str, Any]],
 4597        isOrganizer: bool,
 4598        scoreboards: Sequence[Dict[str, Any]],
 4599        groupDescription: Optional[str] = None,
 4600        groupName: Optional[str] = None,
 4601        # Ignore any unknown arguments
 4602        **_kwargs: Any,
 4603    ):
 4604        self.countries = [_OmegaUp_DAO_VO_Countries(**v) for v in countries]
 4605        self.groupAlias = groupAlias
 4606        if groupDescription is not None:
 4607            self.groupDescription = groupDescription
 4608        else:
 4609            self.groupDescription = None
 4610        if groupName is not None:
 4611            self.groupName = groupName
 4612        else:
 4613            self.groupName = None
 4614        self.identities = [_Identity(**v) for v in identities]
 4615        self.isOrganizer = isOrganizer
 4616        self.scoreboards = [_GroupScoreboard(**v) for v in scoreboards]
 4617
 4618
 4619@dataclasses.dataclass
 4620class _GroupListItem:
 4621    """_GroupListItem"""
 4622    label: str
 4623    value: str
 4624
 4625    def __init__(
 4626        self,
 4627        *,
 4628        label: str,
 4629        value: str,
 4630        # Ignore any unknown arguments
 4631        **_kwargs: Any,
 4632    ):
 4633        self.label = label
 4634        self.value = value
 4635
 4636
 4637@dataclasses.dataclass
 4638class _GroupListPayload:
 4639    """_GroupListPayload"""
 4640    groups: Sequence['_Group']
 4641
 4642    def __init__(
 4643        self,
 4644        *,
 4645        groups: Sequence[Dict[str, Any]],
 4646        # Ignore any unknown arguments
 4647        **_kwargs: Any,
 4648    ):
 4649        self.groups = [_Group(**v) for v in groups]
 4650
 4651
 4652@dataclasses.dataclass
 4653class _GroupScoreboard:
 4654    """_GroupScoreboard"""
 4655    alias: str
 4656    create_time: str
 4657    description: Optional[str]
 4658    name: str
 4659
 4660    def __init__(
 4661        self,
 4662        *,
 4663        alias: str,
 4664        create_time: str,
 4665        name: str,
 4666        description: Optional[str] = None,
 4667        # Ignore any unknown arguments
 4668        **_kwargs: Any,
 4669    ):
 4670        self.alias = alias
 4671        self.create_time = create_time
 4672        if description is not None:
 4673            self.description = description
 4674        else:
 4675            self.description = None
 4676        self.name = name
 4677
 4678
 4679@dataclasses.dataclass
 4680class _GroupScoreboardContestsPayload:
 4681    """_GroupScoreboardContestsPayload"""
 4682    availableContests: Sequence['_ContestListItem']
 4683    contests: Sequence['_ScoreboardContest']
 4684    groupAlias: str
 4685    scoreboardAlias: str
 4686
 4687    def __init__(
 4688        self,
 4689        *,
 4690        availableContests: Sequence[Dict[str, Any]],
 4691        contests: Sequence[Dict[str, Any]],
 4692        groupAlias: str,
 4693        scoreboardAlias: str,
 4694        # Ignore any unknown arguments
 4695        **_kwargs: Any,
 4696    ):
 4697        self.availableContests = [
 4698            _ContestListItem(**v) for v in availableContests
 4699        ]
 4700        self.contests = [_ScoreboardContest(**v) for v in contests]
 4701        self.groupAlias = groupAlias
 4702        self.scoreboardAlias = scoreboardAlias
 4703
 4704
 4705@dataclasses.dataclass
 4706class _GroupScoreboardDetails:
 4707    """_GroupScoreboardDetails"""
 4708    contests: Sequence['_ScoreboardContest']
 4709    ranking: Sequence['_ScoreboardRanking']
 4710    scoreboard: '_ScoreboardDetails'
 4711
 4712    def __init__(
 4713        self,
 4714        *,
 4715        contests: Sequence[Dict[str, Any]],
 4716        ranking: Sequence[Dict[str, Any]],
 4717        scoreboard: Dict[str, Any],
 4718        # Ignore any unknown arguments
 4719        **_kwargs: Any,
 4720    ):
 4721        self.contests = [_ScoreboardContest(**v) for v in contests]
 4722        self.ranking = [_ScoreboardRanking(**v) for v in ranking]
 4723        self.scoreboard = _ScoreboardDetails(**scoreboard)
 4724
 4725
 4726@dataclasses.dataclass
 4727class _GroupScoreboardDetailsPayload:
 4728    """_GroupScoreboardDetailsPayload"""
 4729    details: '_GroupScoreboardDetails'
 4730    groupAlias: str
 4731    scoreboardAlias: str
 4732
 4733    def __init__(
 4734        self,
 4735        *,
 4736        details: Dict[str, Any],
 4737        groupAlias: str,
 4738        scoreboardAlias: str,
 4739        # Ignore any unknown arguments
 4740        **_kwargs: Any,
 4741    ):
 4742        self.details = _GroupScoreboardDetails(**details)
 4743        self.groupAlias = groupAlias
 4744        self.scoreboardAlias = scoreboardAlias
 4745
 4746
 4747@dataclasses.dataclass
 4748class _Histogram:
 4749    """_Histogram"""
 4750    difficulty: float
 4751    difficultyHistogram: Optional[str]
 4752    quality: float
 4753    qualityHistogram: Optional[str]
 4754
 4755    def __init__(
 4756        self,
 4757        *,
 4758        difficulty: float,
 4759        quality: float,
 4760        difficultyHistogram: Optional[str] = None,
 4761        qualityHistogram: Optional[str] = None,
 4762        # Ignore any unknown arguments
 4763        **_kwargs: Any,
 4764    ):
 4765        self.difficulty = difficulty
 4766        if difficultyHistogram is not None:
 4767            self.difficultyHistogram = difficultyHistogram
 4768        else:
 4769            self.difficultyHistogram = None
 4770        self.quality = quality
 4771        if qualityHistogram is not None:
 4772            self.qualityHistogram = qualityHistogram
 4773        else:
 4774            self.qualityHistogram = None
 4775
 4776
 4777@dataclasses.dataclass
 4778class _Identity:
 4779    """_Identity"""
 4780    classname: Optional[str]
 4781    country: Optional[str]
 4782    country_id: Optional[str]
 4783    gender: Optional[str]
 4784    name: Optional[str]
 4785    password: Optional[str]
 4786    school: Optional[str]
 4787    school_id: Optional[int]
 4788    school_name: Optional[str]
 4789    state: Optional[str]
 4790    state_id: Optional[str]
 4791    username: str
 4792
 4793    def __init__(
 4794        self,
 4795        *,
 4796        username: str,
 4797        classname: Optional[str] = None,
 4798        country: Optional[str] = None,
 4799        country_id: Optional[str] = None,
 4800        gender: Optional[str] = None,
 4801        name: Optional[str] = None,
 4802        password: Optional[str] = None,
 4803        school: Optional[str] = None,
 4804        school_id: Optional[int] = None,
 4805        school_name: Optional[str] = None,
 4806        state: Optional[str] = None,
 4807        state_id: Optional[str] = None,
 4808        # Ignore any unknown arguments
 4809        **_kwargs: Any,
 4810    ):
 4811        if classname is not None:
 4812            self.classname = classname
 4813        else:
 4814            self.classname = None
 4815        if country is not None:
 4816            self.country = country
 4817        else:
 4818            self.country = None
 4819        if country_id is not None:
 4820            self.country_id = country_id
 4821        else:
 4822            self.country_id = None
 4823        if gender is not None:
 4824            self.gender = gender
 4825        else:
 4826            self.gender = None
 4827        if name is not None:
 4828            self.name = name
 4829        else:
 4830            self.name = None
 4831        if password is not None:
 4832            self.password = password
 4833        else:
 4834            self.password = None
 4835        if school is not None:
 4836            self.school = school
 4837        else:
 4838            self.school = None
 4839        if school_id is not None:
 4840            self.school_id = school_id
 4841        else:
 4842            self.school_id = None
 4843        if school_name is not None:
 4844            self.school_name = school_name
 4845        else:
 4846            self.school_name = None
 4847        if state is not None:
 4848            self.state = state
 4849        else:
 4850            self.state = None
 4851        if state_id is not None:
 4852            self.state_id = state_id
 4853        else:
 4854            self.state_id = None
 4855        self.username = username
 4856
 4857
 4858@dataclasses.dataclass
 4859class _IdentityExt:
 4860    """_IdentityExt"""
 4861    classname: str
 4862    country_id: Optional[str]
 4863    current_identity_school_id: Optional[int]
 4864    gender: Optional[str]
 4865    identity_id: int
 4866    language_id: Optional[int]
 4867    name: Optional[str]
 4868    password: Optional[str]
 4869    state_id: Optional[str]
 4870    user_id: Optional[int]
 4871    username: str
 4872
 4873    def __init__(
 4874        self,
 4875        *,
 4876        classname: str,
 4877        identity_id: int,
 4878        username: str,
 4879        country_id: Optional[str] = None,
 4880        current_identity_school_id: Optional[int] = None,
 4881        gender: Optional[str] = None,
 4882        language_id: Optional[int] = None,
 4883        name: Optional[str] = None,
 4884        password: Optional[str] = None,
 4885        state_id: Optional[str] = None,
 4886        user_id: Optional[int] = None,
 4887        # Ignore any unknown arguments
 4888        **_kwargs: Any,
 4889    ):
 4890        self.classname = classname
 4891        if country_id is not None:
 4892            self.country_id = country_id
 4893        else:
 4894            self.country_id = None
 4895        if current_identity_school_id is not None:
 4896            self.current_identity_school_id = current_identity_school_id
 4897        else:
 4898            self.current_identity_school_id = None
 4899        if gender is not None:
 4900            self.gender = gender
 4901        else:
 4902            self.gender = None
 4903        self.identity_id = identity_id
 4904        if language_id is not None:
 4905            self.language_id = language_id
 4906        else:
 4907            self.language_id = None
 4908        if name is not None:
 4909            self.name = name
 4910        else:
 4911            self.name = None
 4912        if password is not None:
 4913            self.password = password
 4914        else:
 4915            self.password = None
 4916        if state_id is not None:
 4917            self.state_id = state_id
 4918        else:
 4919            self.state_id = None
 4920        if user_id is not None:
 4921            self.user_id = user_id
 4922        else:
 4923            self.user_id = None
 4924        self.username = username
 4925
 4926
 4927@dataclasses.dataclass
 4928class _IdentityRequest:
 4929    """_IdentityRequest"""
 4930    accepted: Optional[bool]
 4931    admin: Optional['_IdentityRequest_admin']
 4932    classname: str
 4933    country: Optional[str]
 4934    country_id: Optional[str]
 4935    last_update: Optional[datetime.datetime]
 4936    name: Optional[str]
 4937    request_time: datetime.datetime
 4938    username: str
 4939
 4940    def __init__(
 4941        self,
 4942        *,
 4943        classname: str,
 4944        request_time: int,
 4945        username: str,
 4946        accepted: Optional[bool] = None,
 4947        admin: Optional[Dict[str, Any]] = None,
 4948        country: Optional[str] = None,
 4949        country_id: Optional[str] = None,
 4950        last_update: Optional[int] = None,
 4951        name: Optional[str] = None,
 4952        # Ignore any unknown arguments
 4953        **_kwargs: Any,
 4954    ):
 4955        if accepted is not None:
 4956            self.accepted = accepted
 4957        else:
 4958            self.accepted = None
 4959        if admin is not None:
 4960            self.admin = _IdentityRequest_admin(**admin)
 4961        else:
 4962            self.admin = None
 4963        self.classname = classname
 4964        if country is not None:
 4965            self.country = country
 4966        else:
 4967            self.country = None
 4968        if country_id is not None:
 4969            self.country_id = country_id
 4970        else:
 4971            self.country_id = None
 4972        if last_update is not None:
 4973            self.last_update = datetime.datetime.fromtimestamp(last_update)
 4974        else:
 4975            self.last_update = None
 4976        if name is not None:
 4977            self.name = name
 4978        else:
 4979            self.name = None
 4980        self.request_time = datetime.datetime.fromtimestamp(request_time)
 4981        self.username = username
 4982
 4983
 4984@dataclasses.dataclass
 4985class _IdentityRequest_admin:
 4986    """_IdentityRequest_admin"""
 4987    name: Optional[str]
 4988    username: str
 4989
 4990    def __init__(
 4991        self,
 4992        *,
 4993        username: str,
 4994        name: Optional[str] = None,
 4995        # Ignore any unknown arguments
 4996        **_kwargs: Any,
 4997    ):
 4998        if name is not None:
 4999            self.name = name
 5000        else:
 5001            self.name = None
 5002        self.username = username
 5003
 5004
 5005@dataclasses.dataclass
 5006class _IndexPayload:
 5007    """_IndexPayload"""
 5008    coderOfTheMonthData: '_IndexPayload_coderOfTheMonthData'
 5009    currentUserInfo: '_IndexPayload_currentUserInfo'
 5010    schoolOfTheMonthData: Optional['_IndexPayload_schoolOfTheMonthData']
 5011    schoolRank: Sequence['_IndexPayload_schoolRank_entry']
 5012    userRank: Sequence['_CoderOfTheMonth']
 5013
 5014    def __init__(
 5015        self,
 5016        *,
 5017        coderOfTheMonthData: Dict[str, Any],
 5018        currentUserInfo: Dict[str, Any],
 5019        schoolRank: Sequence[Dict[str, Any]],
 5020        userRank: Sequence[Dict[str, Any]],
 5021        schoolOfTheMonthData: Optional[Dict[str, Any]] = None,
 5022        # Ignore any unknown arguments
 5023        **_kwargs: Any,
 5024    ):
 5025        self.coderOfTheMonthData = _IndexPayload_coderOfTheMonthData(
 5026            **coderOfTheMonthData)
 5027        self.currentUserInfo = _IndexPayload_currentUserInfo(**currentUserInfo)
 5028        if schoolOfTheMonthData is not None:
 5029            self.schoolOfTheMonthData = _IndexPayload_schoolOfTheMonthData(
 5030                **schoolOfTheMonthData)
 5031        else:
 5032            self.schoolOfTheMonthData = None
 5033        self.schoolRank = [
 5034            _IndexPayload_schoolRank_entry(**v) for v in schoolRank
 5035        ]
 5036        self.userRank = [_CoderOfTheMonth(**v) for v in userRank]
 5037
 5038
 5039@dataclasses.dataclass
 5040class _IndexPayload_coderOfTheMonthData:
 5041    """_IndexPayload_coderOfTheMonthData"""
 5042    all: Optional['_UserProfile']
 5043    female: Optional['_UserProfile']
 5044
 5045    def __init__(
 5046        self,
 5047        *,
 5048        all: Optional[Dict[str, Any]] = None,
 5049        female: Optional[Dict[str, Any]] = None,
 5050        # Ignore any unknown arguments
 5051        **_kwargs: Any,
 5052    ):
 5053        if all is not None:
 5054            self.all = _UserProfile(**all)
 5055        else:
 5056            self.all = None
 5057        if female is not None:
 5058            self.female = _UserProfile(**female)
 5059        else:
 5060            self.female = None
 5061
 5062
 5063@dataclasses.dataclass
 5064class _IndexPayload_currentUserInfo:
 5065    """_IndexPayload_currentUserInfo"""
 5066    username: Optional[str]
 5067
 5068    def __init__(
 5069        self,
 5070        *,
 5071        username: Optional[str] = None,
 5072        # Ignore any unknown arguments
 5073        **_kwargs: Any,
 5074    ):
 5075        if username is not None:
 5076            self.username = username
 5077        else:
 5078            self.username = None
 5079
 5080
 5081@dataclasses.dataclass
 5082class _IndexPayload_schoolOfTheMonthData:
 5083    """_IndexPayload_schoolOfTheMonthData"""
 5084    country: Optional[str]
 5085    country_id: Optional[str]
 5086    name: str
 5087    school_id: int
 5088    state: Optional[str]
 5089
 5090    def __init__(
 5091        self,
 5092        *,
 5093        name: str,
 5094        school_id: int,
 5095        country: Optional[str] = None,
 5096        country_id: Optional[str] = None,
 5097        state: Optional[str] = None,
 5098        # Ignore any unknown arguments
 5099        **_kwargs: Any,
 5100    ):
 5101        if country is not None:
 5102            self.country = country
 5103        else:
 5104            self.country = None
 5105        if country_id is not None:
 5106            self.country_id = country_id
 5107        else:
 5108            self.country_id = None
 5109        self.name = name
 5110        self.school_id = school_id
 5111        if state is not None:
 5112            self.state = state
 5113        else:
 5114            self.state = None
 5115
 5116
 5117@dataclasses.dataclass
 5118class _IndexPayload_schoolRank_entry:
 5119    """_IndexPayload_schoolRank_entry"""
 5120    name: str
 5121    ranking: int
 5122    school_id: int
 5123    school_of_the_month_id: int
 5124    score: float
 5125
 5126    def __init__(
 5127        self,
 5128        *,
 5129        name: str,
 5130        ranking: int,
 5131        school_id: int,
 5132        school_of_the_month_id: int,
 5133        score: float,
 5134        # Ignore any unknown arguments
 5135        **_kwargs: Any,
 5136    ):
 5137        self.name = name
 5138        self.ranking = ranking
 5139        self.school_id = school_id
 5140        self.school_of_the_month_id = school_of_the_month_id
 5141        self.score = score
 5142
 5143
 5144@dataclasses.dataclass
 5145class _InteractiveInterface:
 5146    """_InteractiveInterface"""
 5147    ExecutableDescription: '_InteractiveInterface_ExecutableDescription'
 5148    Files: Dict[str, str]
 5149    MakefileRules: Sequence['_InteractiveInterface_MakefileRules_entry']
 5150
 5151    def __init__(
 5152        self,
 5153        *,
 5154        ExecutableDescription: Dict[str, Any],
 5155        Files: Dict[str, str],
 5156        MakefileRules: Sequence[Dict[str, Any]],
 5157        # Ignore any unknown arguments
 5158        **_kwargs: Any,
 5159    ):
 5160        self.ExecutableDescription = _InteractiveInterface_ExecutableDescription(
 5161            **ExecutableDescription)
 5162        self.Files = {k: v for k, v in Files.items()}
 5163        self.MakefileRules = [
 5164            _InteractiveInterface_MakefileRules_entry(**v)
 5165            for v in MakefileRules
 5166        ]
 5167
 5168
 5169@dataclasses.dataclass
 5170class _InteractiveInterface_ExecutableDescription:
 5171    """_InteractiveInterface_ExecutableDescription"""
 5172    Args: Sequence[str]
 5173    Env: Dict[str, str]
 5174
 5175    def __init__(
 5176        self,
 5177        *,
 5178        Args: Sequence[str],
 5179        Env: Dict[str, str],
 5180        # Ignore any unknown arguments
 5181        **_kwargs: Any,
 5182    ):
 5183        self.Args = [v for v in Args]
 5184        self.Env = {k: v for k, v in Env.items()}
 5185
 5186
 5187@dataclasses.dataclass
 5188class _InteractiveInterface_MakefileRules_entry:
 5189    """_InteractiveInterface_MakefileRules_entry"""
 5190    Compiler: str
 5191    Debug: bool
 5192    Params: str
 5193    Requisites: Sequence[str]
 5194    Targets: Sequence[str]
 5195
 5196    def __init__(
 5197        self,
 5198        *,
 5199        Compiler: str,
 5200        Debug: bool,
 5201        Params: str,
 5202        Requisites: Sequence[str],
 5203        Targets: Sequence[str],
 5204        # Ignore any unknown arguments
 5205        **_kwargs: Any,
 5206    ):
 5207        self.Compiler = Compiler
 5208        self.Debug = Debug
 5209        self.Params = Params
 5210        self.Requisites = [v for v in Requisites]
 5211        self.Targets = [v for v in Targets]
 5212
 5213
 5214@dataclasses.dataclass
 5215class _InteractiveSettingsDistrib:
 5216    """_InteractiveSettingsDistrib"""
 5217    idl: str
 5218    language: str
 5219    main_source: str
 5220    module_name: str
 5221    templates: Dict[str, str]
 5222
 5223    def __init__(
 5224        self,
 5225        *,
 5226        idl: str,
 5227        language: str,
 5228        main_source: str,
 5229        module_name: str,
 5230        templates: Dict[str, str],
 5231        # Ignore any unknown arguments
 5232        **_kwargs: Any,
 5233    ):
 5234        self.idl = idl
 5235        self.language = language
 5236        self.main_source = main_source
 5237        self.module_name = module_name
 5238        self.templates = {k: v for k, v in templates.items()}
 5239
 5240
 5241@dataclasses.dataclass
 5242class _IntroCourseDetails:
 5243    """_IntroCourseDetails"""
 5244    details: '_CourseDetails'
 5245    progress: Dict[str, Dict[str, float]]
 5246
 5247    def __init__(
 5248        self,
 5249        *,
 5250        details: Dict[str, Any],
 5251        progress: Dict[str, Dict[str, float]],
 5252        # Ignore any unknown arguments
 5253        **_kwargs: Any,
 5254    ):
 5255        self.details = _CourseDetails(**details)
 5256        self.progress = {
 5257            k: {k: v
 5258                for k, v in v.items()}
 5259            for k, v in progress.items()
 5260        }
 5261
 5262
 5263@dataclasses.dataclass
 5264class _IntroDetailsPayload:
 5265    """_IntroDetailsPayload"""
 5266    course: '_CourseDetails'
 5267    isFirstTimeAccess: bool
 5268    needsBasicInformation: bool
 5269    shouldShowAcceptTeacher: bool
 5270    shouldShowResults: bool
 5271    statements: '_IntroDetailsPayload_statements'
 5272    userRegistrationAccepted: Optional[bool]
 5273    userRegistrationAnswered: Optional[bool]
 5274    userRegistrationRequested: Optional[bool]
 5275
 5276    def __init__(
 5277        self,
 5278        *,
 5279        course: Dict[str, Any],
 5280        isFirstTimeAccess: bool,
 5281        needsBasicInformation: bool,
 5282        shouldShowAcceptTeacher: bool,
 5283        shouldShowResults: bool,
 5284        statements: Dict[str, Any],
 5285        userRegistrationAccepted: Optional[bool] = None,
 5286        userRegistrationAnswered: Optional[bool] = None,
 5287        userRegistrationRequested: Optional[bool] = None,
 5288        # Ignore any unknown arguments
 5289        **_kwargs: Any,
 5290    ):
 5291        self.course = _CourseDetails(**course)
 5292        self.isFirstTimeAccess = isFirstTimeAccess
 5293        self.needsBasicInformation = needsBasicInformation
 5294        self.shouldShowAcceptTeacher = shouldShowAcceptTeacher
 5295        self.shouldShowResults = shouldShowResults
 5296        self.statements = _IntroDetailsPayload_statements(**statements)
 5297        if userRegistrationAccepted is not None:
 5298            self.userRegistrationAccepted = userRegistrationAccepted
 5299        else:
 5300            self.userRegistrationAccepted = None
 5301        if userRegistrationAnswered is not None:
 5302            self.userRegistrationAnswered = userRegistrationAnswered
 5303        else:
 5304            self.userRegistrationAnswered = None
 5305        if userRegistrationRequested is not None:
 5306            self.userRegistrationRequested = userRegistrationRequested
 5307        else:
 5308            self.userRegistrationRequested = None
 5309
 5310
 5311@dataclasses.dataclass
 5312class _IntroDetailsPayload_statements:
 5313    """_IntroDetailsPayload_statements"""
 5314    acceptTeacher: Optional['_PrivacyStatement']
 5315    privacy: Optional['_PrivacyStatement']
 5316
 5317    def __init__(
 5318        self,
 5319        *,
 5320        acceptTeacher: Optional[Dict[str, Any]] = None,
 5321        privacy: Optional[Dict[str, Any]] = None,
 5322        # Ignore any unknown arguments
 5323        **_kwargs: Any,
 5324    ):
 5325        if acceptTeacher is not None:
 5326            self.acceptTeacher = _PrivacyStatement(**acceptTeacher)
 5327        else:
 5328            self.acceptTeacher = None
 5329        if privacy is not None:
 5330            self.privacy = _PrivacyStatement(**privacy)
 5331        else:
 5332            self.privacy = None
 5333
 5334
 5335@dataclasses.dataclass
 5336class _LibinteractiveError:
 5337    """_LibinteractiveError"""
 5338    description: str
 5339    field: str
 5340
 5341    def __init__(
 5342        self,
 5343        *,
 5344        description: str,
 5345        field: str,
 5346        # Ignore any unknown arguments
 5347        **_kwargs: Any,
 5348    ):
 5349        self.description = description
 5350        self.field = field
 5351
 5352
 5353@dataclasses.dataclass
 5354class _LibinteractiveGenPayload:
 5355    """_LibinteractiveGenPayload"""
 5356    error: Optional['_LibinteractiveError']
 5357    idl: Optional[str]
 5358    language: Optional[str]
 5359    name: Optional[str]
 5360    os: Optional[str]
 5361
 5362    def __init__(
 5363        self,
 5364        *,
 5365        error: Optional[Dict[str, Any]] = None,
 5366        idl: Optional[str] = None,
 5367        language: Optional[str] = None,
 5368        name: Optional[str] = None,
 5369        os: Optional[str] = None,
 5370        # Ignore any unknown arguments
 5371        **_kwargs: Any,
 5372    ):
 5373        if error is not None:
 5374            self.error = _LibinteractiveError(**error)
 5375        else:
 5376            self.error = None
 5377        if idl is not None:
 5378            self.idl = idl
 5379        else:
 5380            self.idl = None
 5381        if language is not None:
 5382            self.language = language
 5383        else:
 5384            self.language = None
 5385        if name is not None:
 5386            self.name = name
 5387        else:
 5388            self.name = None
 5389        if os is not None:
 5390            self.os = os
 5391        else:
 5392            self.os = None
 5393
 5394
 5395@dataclasses.dataclass
 5396class _LimitsSettings:
 5397    """_LimitsSettings"""
 5398    ExtraWallTime: str
 5399    MemoryLimit: Union[int, str]
 5400    OutputLimit: Union[int, str]
 5401    OverallWallTimeLimit: str
 5402    TimeLimit: str
 5403
 5404    def __init__(
 5405        self,
 5406        *,
 5407        ExtraWallTime: str,
 5408        MemoryLimit: Union[int, str],
 5409        OutputLimit: Union[int, str],
 5410        OverallWallTimeLimit: str,
 5411        TimeLimit: str,
 5412        # Ignore any unknown arguments
 5413        **_kwargs: Any,
 5414    ):
 5415        self.ExtraWallTime = ExtraWallTime
 5416        self.MemoryLimit = MemoryLimit
 5417        self.OutputLimit = OutputLimit
 5418        self.OverallWallTimeLimit = OverallWallTimeLimit
 5419        self.TimeLimit = TimeLimit
 5420
 5421
 5422@dataclasses.dataclass
 5423class _ListItem:
 5424    """_ListItem"""
 5425    key: str
 5426    value: str
 5427
 5428    def __init__(
 5429        self,
 5430        *,
 5431        key: str,
 5432        value: str,
 5433        # Ignore any unknown arguments
 5434        **_kwargs: Any,
 5435    ):
 5436        self.key = key
 5437        self.value = value
 5438
 5439
 5440@dataclasses.dataclass
 5441class _LoginDetailsPayload:
 5442    """_LoginDetailsPayload"""
 5443    facebookUrl: Optional[str]
 5444    statusError: Optional[str]
 5445    validateRecaptcha: bool
 5446    verifyEmailSuccessfully: Optional[str]
 5447
 5448    def __init__(
 5449        self,
 5450        *,
 5451        validateRecaptcha: bool,
 5452        facebookUrl: Optional[str] = None,
 5453        statusError: Optional[str] = None,
 5454        verifyEmailSuccessfully: Optional[str] = None,
 5455        # Ignore any unknown arguments
 5456        **_kwargs: Any,
 5457    ):
 5458        if facebookUrl is not None:
 5459            self.facebookUrl = facebookUrl
 5460        else:
 5461            self.facebookUrl = None
 5462        if statusError is not None:
 5463            self.statusError = statusError
 5464        else:
 5465            self.statusError = None
 5466        self.validateRecaptcha = validateRecaptcha
 5467        if verifyEmailSuccessfully is not None:
 5468            self.verifyEmailSuccessfully = verifyEmailSuccessfully
 5469        else:
 5470            self.verifyEmailSuccessfully = None
 5471
 5472
 5473@dataclasses.dataclass
 5474class _MergedScoreboardEntry:
 5475    """_MergedScoreboardEntry"""
 5476    contests: Dict[str, '_MergedScoreboardEntry_contests_value']
 5477    name: Optional[str]
 5478    place: Optional[int]
 5479    total: '_MergedScoreboardEntry_total'
 5480    username: str
 5481
 5482    def __init__(
 5483        self,
 5484        *,
 5485        contests: Dict[str, Dict[str, Any]],
 5486        total: Dict[str, Any],
 5487        username: str,
 5488        name: Optional[str] = None,
 5489        place: Optional[int] = None,
 5490        # Ignore any unknown arguments
 5491        **_kwargs: Any,
 5492    ):
 5493        self.contests = {
 5494            k: _MergedScoreboardEntry_contests_value(**v)
 5495            for k, v in contests.items()
 5496        }
 5497        if name is not None:
 5498            self.name = name
 5499        else:
 5500            self.name = None
 5501        if place is not None:
 5502            self.place = place
 5503        else:
 5504            self.place = None
 5505        self.total = _MergedScoreboardEntry_total(**total)
 5506        self.username = username
 5507
 5508
 5509@dataclasses.dataclass
 5510class _MergedScoreboardEntry_contests_value:
 5511    """_MergedScoreboardEntry_contests_value"""
 5512    penalty: float
 5513    points: float
 5514
 5515    def __init__(
 5516        self,
 5517        *,
 5518        penalty: float,
 5519        points: float,
 5520        # Ignore any unknown arguments
 5521        **_kwargs: Any,
 5522    ):
 5523        self.penalty = penalty
 5524        self.points = points
 5525
 5526
 5527@dataclasses.dataclass
 5528class _MergedScoreboardEntry_total:
 5529    """_MergedScoreboardEntry_total"""
 5530    penalty: float
 5531    points: float
 5532
 5533    def __init__(
 5534        self,
 5535        *,
 5536        penalty: float,
 5537        points: float,
 5538        # Ignore any unknown arguments
 5539        **_kwargs: Any,
 5540    ):
 5541        self.penalty = penalty
 5542        self.points = points
 5543
 5544
 5545@dataclasses.dataclass
 5546class _NavbarProblemsetProblem:
 5547    """_NavbarProblemsetProblem"""
 5548    acceptsSubmissions: bool
 5549    alias: str
 5550    bestScore: int
 5551    hasRuns: bool
 5552    maxScore: Union[float, int]
 5553    text: str
 5554
 5555    def __init__(
 5556        self,
 5557        *,
 5558        acceptsSubmissions: bool,
 5559        alias: str,
 5560        bestScore: int,
 5561        hasRuns: bool,
 5562        maxScore: Union[float, int],
 5563        text: str,
 5564        # Ignore any unknown arguments
 5565        **_kwargs: Any,
 5566    ):
 5567        self.acceptsSubmissions = acceptsSubmissions
 5568        self.alias = alias
 5569        self.bestScore = bestScore
 5570        self.hasRuns = hasRuns
 5571        self.maxScore = maxScore
 5572        self.text = text
 5573
 5574
 5575@dataclasses.dataclass
 5576class _NominationListItem:
 5577    """_NominationListItem"""
 5578    author: '_NominationListItem_author'
 5579    contents: Optional['_NominationListItem_contents']
 5580    nomination: str
 5581    nominator: '_NominationListItem_nominator'
 5582    problem: '_NominationListItem_problem'
 5583    qualitynomination_id: int
 5584    status: str
 5585    time: datetime.datetime
 5586    votes: Sequence['_NominationListItem_votes_entry']
 5587
 5588    def __init__(
 5589        self,
 5590        *,
 5591        author: Dict[str, Any],
 5592        nomination: str,
 5593        nominator: Dict[str, Any],
 5594        problem: Dict[str, Any],
 5595        qualitynomination_id: int,
 5596        status: str,
 5597        time: int,
 5598        votes: Sequence[Dict[str, Any]],
 5599        contents: Optional[Dict[str, Any]] = None,
 5600        # Ignore any unknown arguments
 5601        **_kwargs: Any,
 5602    ):
 5603        self.author = _NominationListItem_author(**author)
 5604        if contents is not None:
 5605            self.contents = _NominationListItem_contents(**contents)
 5606        else:
 5607            self.contents = None
 5608        self.nomination = nomination
 5609        self.nominator = _NominationListItem_nominator(**nominator)
 5610        self.problem = _NominationListItem_problem(**problem)
 5611        self.qualitynomination_id = qualitynomination_id
 5612        self.status = status
 5613        self.time = datetime.datetime.fromtimestamp(time)
 5614        self.votes = [_NominationListItem_votes_entry(**v) for v in votes]
 5615
 5616
 5617@dataclasses.dataclass
 5618class _NominationListItem_author:
 5619    """_NominationListItem_author"""
 5620    name: Optional[str]
 5621    username: str
 5622
 5623    def __init__(
 5624        self,
 5625        *,
 5626        username: str,
 5627        name: Optional[str] = None,
 5628        # Ignore any unknown arguments
 5629        **_kwargs: Any,
 5630    ):
 5631        if name is not None:
 5632            self.name = name
 5633        else:
 5634            self.name = None
 5635        self.username = username
 5636
 5637
 5638@dataclasses.dataclass
 5639class _NominationListItem_contents:
 5640    """_NominationListItem_contents"""
 5641    before_ac: Optional[bool]
 5642    difficulty: Optional[int]
 5643    quality: Optional[int]
 5644    rationale: Optional[str]
 5645    reason: Optional[str]
 5646    statements: Optional[Dict[str, str]]
 5647    tags: Optional[Sequence[str]]
 5648
 5649    def __init__(
 5650        self,
 5651        *,
 5652        before_ac: Optional[bool] = None,
 5653        difficulty: Optional[int] = None,
 5654        quality: Optional[int] = None,
 5655        rationale: Optional[str] = None,
 5656        reason: Optional[str] = None,
 5657        statements: Optional[Dict[str, str]] = None,
 5658        tags: Optional[Sequence[str]] = None,
 5659        # Ignore any unknown arguments
 5660        **_kwargs: Any,
 5661    ):
 5662        if before_ac is not None:
 5663            self.before_ac = before_ac
 5664        else:
 5665            self.before_ac = None
 5666        if difficulty is not None:
 5667            self.difficulty = difficulty
 5668        else:
 5669            self.difficulty = None
 5670        if quality is not None:
 5671            self.quality = quality
 5672        else:
 5673            self.quality = None
 5674        if rationale is not None:
 5675            self.rationale = rationale
 5676        else:
 5677            self.rationale = None
 5678        if reason is not None:
 5679            self.reason = reason
 5680        else:
 5681            self.reason = None
 5682        if statements is not None:
 5683            self.statements = {k: v for k, v in statements.items()}
 5684        else:
 5685            self.statements = None
 5686        if tags is not None:
 5687            self.tags = [v for v in tags]
 5688        else:
 5689            self.tags = None
 5690
 5691
 5692@dataclasses.dataclass
 5693class _NominationListItem_nominator:
 5694    """_NominationListItem_nominator"""
 5695    name: Optional[str]
 5696    username: str
 5697
 5698    def __init__(
 5699        self,
 5700        *,
 5701        username: str,
 5702        name: Optional[str] = None,
 5703        # Ignore any unknown arguments
 5704        **_kwargs: Any,
 5705    ):
 5706        if name is not None:
 5707            self.name = name
 5708        else:
 5709            self.name = None
 5710        self.username = username
 5711
 5712
 5713@dataclasses.dataclass
 5714class _NominationListItem_problem:
 5715    """_NominationListItem_problem"""
 5716    alias: str
 5717    title: str
 5718
 5719    def __init__(
 5720        self,
 5721        *,
 5722        alias: str,
 5723        title: str,
 5724        # Ignore any unknown arguments
 5725        **_kwargs: Any,
 5726    ):
 5727        self.alias = alias
 5728        self.title = title
 5729
 5730
 5731@dataclasses.dataclass
 5732class _NominationListItem_votes_entry:
 5733    """_NominationListItem_votes_entry"""
 5734    time: Optional[datetime.datetime]
 5735    user: '_NominationListItem_votes_entry_user'
 5736    vote: int
 5737
 5738    def __init__(
 5739        self,
 5740        *,
 5741        user: Dict[str, Any],
 5742        vote: int,
 5743        time: Optional[int] = None,
 5744        # Ignore any unknown arguments
 5745        **_kwargs: Any,
 5746    ):
 5747        if time is not None:
 5748            self.time = datetime.datetime.fromtimestamp(time)
 5749        else:
 5750            self.time = None
 5751        self.user = _NominationListItem_votes_entry_user(**user)
 5752        self.vote = vote
 5753
 5754
 5755@dataclasses.dataclass
 5756class _NominationListItem_votes_entry_user:
 5757    """_NominationListItem_votes_entry_user"""
 5758    name: Optional[str]
 5759    username: str
 5760
 5761    def __init__(
 5762        self,
 5763        *,
 5764        username: str,
 5765        name: Optional[str] = None,
 5766        # Ignore any unknown arguments
 5767        **_kwargs: Any,
 5768    ):
 5769        if name is not None:
 5770            self.name = name
 5771        else:
 5772            self.name = None
 5773        self.username = username
 5774
 5775
 5776@dataclasses.dataclass
 5777class _NominationStatus:
 5778    """_NominationStatus"""
 5779    alreadyReviewed: bool
 5780    canNominateProblem: bool
 5781    dismissed: bool
 5782    dismissedBeforeAc: bool
 5783    language: str
 5784    nominated: bool
 5785    nominatedBeforeAc: bool
 5786    solved: bool
 5787    tried: bool
 5788
 5789    def __init__(
 5790        self,
 5791        *,
 5792        alreadyReviewed: bool,
 5793        canNominateProblem: bool,
 5794        dismissed: bool,
 5795        dismissedBeforeAc: bool,
 5796        language: str,
 5797        nominated: bool,
 5798        nominatedBeforeAc: bool,
 5799        solved: bool,
 5800        tried: bool,
 5801        # Ignore any unknown arguments
 5802        **_kwargs: Any,
 5803    ):
 5804        self.alreadyReviewed = alreadyReviewed
 5805        self.canNominateProblem = canNominateProblem
 5806        self.dismissed = dismissed
 5807        self.dismissedBeforeAc = dismissedBeforeAc
 5808        self.language = language
 5809        self.nominated = nominated
 5810        self.nominatedBeforeAc = nominatedBeforeAc
 5811        self.solved = solved
 5812        self.tried = tried
 5813
 5814
 5815@dataclasses.dataclass
 5816class _Notification:
 5817    """_Notification"""
 5818    contents: '_NotificationContents'
 5819    notification_id: int
 5820    timestamp: datetime.datetime
 5821
 5822    def __init__(
 5823        self,
 5824        *,
 5825        contents: Dict[str, Any],
 5826        notification_id: int,
 5827        timestamp: int,
 5828        # Ignore any unknown arguments
 5829        **_kwargs: Any,
 5830    ):
 5831        self.contents = _NotificationContents(**contents)
 5832        self.notification_id = notification_id
 5833        self.timestamp = datetime.datetime.fromtimestamp(timestamp)
 5834
 5835
 5836@dataclasses.dataclass
 5837class _NotificationContents:
 5838    """_NotificationContents"""
 5839    badge: Optional[str]
 5840    body: Optional['_NotificationContents_body']
 5841    message: Optional[str]
 5842    status: Optional[str]
 5843    type: str
 5844    url: Optional[str]
 5845
 5846    def __init__(
 5847        self,
 5848        *,
 5849        type: str,
 5850        badge: Optional[str] = None,
 5851        body: Optional[Dict[str, Any]] = None,
 5852        message: Optional[str] = None,
 5853        status: Optional[str] = None,
 5854        url: Optional[str] = None,
 5855        # Ignore any unknown arguments
 5856        **_kwargs: Any,
 5857    ):
 5858        if badge is not None:
 5859            self.badge = badge
 5860        else:
 5861            self.badge = None
 5862        if body is not None:
 5863            self.body = _NotificationContents_body(**body)
 5864        else:
 5865            self.body = None
 5866        if message is not None:
 5867            self.message = message
 5868        else:
 5869            self.message = None
 5870        if status is not None:
 5871            self.status = status
 5872        else:
 5873            self.status = None
 5874        self.type = type
 5875        if url is not None:
 5876            self.url = url
 5877        else:
 5878            self.url = None
 5879
 5880
 5881@dataclasses.dataclass
 5882class _NotificationContents_body:
 5883    """_NotificationContents_body"""
 5884    iconUrl: str
 5885    localizationParams: Sequence[str]
 5886    localizationString: str
 5887    url: str
 5888
 5889    def __init__(
 5890        self,
 5891        *,
 5892        iconUrl: str,
 5893        localizationParams: Sequence[str],
 5894        localizationString: str,
 5895        url: str,
 5896        # Ignore any unknown arguments
 5897        **_kwargs: Any,
 5898    ):
 5899        self.iconUrl = iconUrl
 5900        self.localizationParams = [v for v in localizationParams]
 5901        self.localizationString = localizationString
 5902        self.url = url
 5903
 5904
 5905@dataclasses.dataclass
 5906class _OmegaUp_Controllers_Admin__apiPlatformReportStats:
 5907    """_OmegaUp_Controllers_Admin__apiPlatformReportStats"""
 5908    report: '_OmegaUp_Controllers_Admin__apiPlatformReportStats_report'
 5909
 5910    def __init__(
 5911        self,
 5912        *,
 5913        report: Dict[str, Any],
 5914        # Ignore any unknown arguments
 5915        **_kwargs: Any,
 5916    ):
 5917        self.report = _OmegaUp_Controllers_Admin__apiPlatformReportStats_report(
 5918            **report)
 5919
 5920
 5921@dataclasses.dataclass
 5922class _OmegaUp_Controllers_Admin__apiPlatformReportStats_report:
 5923    """_OmegaUp_Controllers_Admin__apiPlatformReportStats_report"""
 5924    acceptedSubmissions: int
 5925    activeSchools: int
 5926    activeUsers: Dict[str, int]
 5927    courses: int
 5928    omiCourse: '_OmegaUp_Controllers_Admin__apiPlatformReportStats_report_omiCourse'
 5929
 5930    def __init__(
 5931        self,
 5932        *,
 5933        acceptedSubmissions: int,
 5934        activeSchools: int,
 5935        activeUsers: Dict[str, int],
 5936        courses: int,
 5937        omiCourse: Dict[str, Any],
 5938        # Ignore any unknown arguments
 5939        **_kwargs: Any,
 5940    ):
 5941        self.acceptedSubmissions = acceptedSubmissions
 5942        self.activeSchools = activeSchools
 5943        self.activeUsers = {k: v for k, v in activeUsers.items()}
 5944        self.courses = courses
 5945        self.omiCourse = _OmegaUp_Controllers_Admin__apiPlatformReportStats_report_omiCourse(
 5946            **omiCourse)
 5947
 5948
 5949@dataclasses.dataclass
 5950class _OmegaUp_Controllers_Admin__apiPlatformReportStats_report_omiCourse:
 5951    """_OmegaUp_Controllers_Admin__apiPlatformReportStats_report_omiCourse"""
 5952    attemptedUsers: int
 5953    completedUsers: int
 5954    passedUsers: int
 5955
 5956    def __init__(
 5957        self,
 5958        *,
 5959        attemptedUsers: int,
 5960        completedUsers: int,
 5961        passedUsers: int,
 5962        # Ignore any unknown arguments
 5963        **_kwargs: Any,
 5964    ):
 5965        self.attemptedUsers = attemptedUsers
 5966        self.completedUsers = completedUsers
 5967        self.passedUsers = passedUsers
 5968
 5969
 5970@dataclasses.dataclass
 5971class _OmegaUp_Controllers_Authorization__apiProblem:
 5972    """_OmegaUp_Controllers_Authorization__apiProblem"""
 5973    can_edit: bool
 5974    can_view: bool
 5975    has_solved: bool
 5976    is_admin: bool
 5977
 5978    def __init__(
 5979        self,
 5980        *,
 5981        can_edit: bool,
 5982        can_view: bool,
 5983        has_solved: bool,
 5984        is_admin: bool,
 5985        # Ignore any unknown arguments
 5986        **_kwargs: Any,
 5987    ):
 5988        self.can_edit = can_edit
 5989        self.can_view = can_view
 5990        self.has_solved = has_solved
 5991        self.is_admin = is_admin
 5992
 5993
 5994@dataclasses.dataclass
 5995class _OmegaUp_Controllers_Badge__apiMyBadgeAssignationTime:
 5996    """_OmegaUp_Controllers_Badge__apiMyBadgeAssignationTime"""
 5997    assignation_time: Optional[datetime.datetime]
 5998
 5999    def __init__(
 6000        self,
 6001        *,
 6002        assignation_time: Optional[int] = None,
 6003        # Ignore any unknown arguments
 6004        **_kwargs: Any,
 6005    ):
 6006        if assignation_time is not None:
 6007            self.assignation_time = datetime.datetime.fromtimestamp(
 6008                assignation_time)
 6009        else:
 6010            self.assignation_time = None
 6011
 6012
 6013@dataclasses.dataclass
 6014class _OmegaUp_Controllers_Badge__apiMyList:
 6015    """_OmegaUp_Controllers_Badge__apiMyList"""
 6016    badges: Sequence['_Badge']
 6017
 6018    def __init__(
 6019        self,
 6020        *,
 6021        badges: Sequence[Dict[str, Any]],
 6022        # Ignore any unknown arguments
 6023        **_kwargs: Any,
 6024    ):
 6025        self.badges = [_Badge(**v) for v in badges]
 6026
 6027
 6028@dataclasses.dataclass
 6029class _OmegaUp_Controllers_Badge__apiUserList:
 6030    """_OmegaUp_Controllers_Badge__apiUserList"""
 6031    badges: Sequence['_Badge']
 6032
 6033    def __init__(
 6034        self,
 6035        *,
 6036        badges: Sequence[Dict[str, Any]],
 6037        # Ignore any unknown arguments
 6038        **_kwargs: Any,
 6039    ):
 6040        self.badges = [_Badge(**v) for v in badges]
 6041
 6042
 6043@dataclasses.dataclass
 6044class _OmegaUp_Controllers_Clarification__apiDetails:
 6045    """_OmegaUp_Controllers_Clarification__apiDetails"""
 6046    answer: Optional[str]
 6047    message: str
 6048    problem_id: int
 6049    problemset_id: Optional[int]
 6050    time: datetime.datetime
 6051
 6052    def __init__(
 6053        self,
 6054        *,
 6055        message: str,
 6056        problem_id: int,
 6057        time: int,
 6058        answer: Optional[str] = None,
 6059        problemset_id: Optional[int] = None,
 6060        # Ignore any unknown arguments
 6061        **_kwargs: Any,
 6062    ):
 6063        if answer is not None:
 6064            self.answer = answer
 6065        else:
 6066            self.answer = None
 6067        self.message = message
 6068        self.problem_id = problem_id
 6069        if problemset_id is not None:
 6070            self.problemset_id = problemset_id
 6071        else:
 6072            self.problemset_id = None
 6073        self.time = datetime.datetime.fromtimestamp(time)
 6074
 6075
 6076@dataclasses.dataclass
 6077class _OmegaUp_Controllers_Contest__apiActivityReport:
 6078    """_OmegaUp_Controllers_Contest__apiActivityReport"""
 6079    events: Sequence['_ActivityEvent']
 6080    pagerItems: Sequence['_PageItem']
 6081
 6082    def __init__(
 6083        self,
 6084        *,
 6085        events: Sequence[Dict[str, Any]],
 6086        pagerItems: Sequence[Dict[str, Any]],
 6087        # Ignore any unknown arguments
 6088        **_kwargs: Any,
 6089    ):
 6090        self.events = [_ActivityEvent(**v) for v in events]
 6091        self.pagerItems = [_PageItem(**v) for v in pagerItems]
 6092
 6093
 6094@dataclasses.dataclass
 6095class _OmegaUp_Controllers_Contest__apiAdminList:
 6096    """_OmegaUp_Controllers_Contest__apiAdminList"""
 6097    contests: Sequence['_Contest']
 6098
 6099    def __init__(
 6100        self,
 6101        *,
 6102        contests: Sequence[Dict[str, Any]],
 6103        # Ignore any unknown arguments
 6104        **_kwargs: Any,
 6105    ):
 6106        self.contests = [_Contest(**v) for v in contests]
 6107
 6108
 6109@dataclasses.dataclass
 6110class _OmegaUp_Controllers_Contest__apiAdmins:
 6111    """_OmegaUp_Controllers_Contest__apiAdmins"""
 6112    admins: Sequence['_OmegaUp_Controllers_Contest__apiAdmins_admins_entry']
 6113    group_admins: Sequence[
 6114        '_OmegaUp_Controllers_Contest__apiAdmins_group_admins_entry']
 6115
 6116    def __init__(
 6117        self,
 6118        *,
 6119        admins: Sequence[Dict[str, Any]],
 6120        group_admins: Sequence[Dict[str, Any]],
 6121        # Ignore any unknown arguments
 6122        **_kwargs: Any,
 6123    ):
 6124        self.admins = [
 6125            _OmegaUp_Controllers_Contest__apiAdmins_admins_entry(**v)
 6126            for v in admins
 6127        ]
 6128        self.group_admins = [
 6129            _OmegaUp_Controllers_Contest__apiAdmins_group_admins_entry(**v)
 6130            for v in group_admins
 6131        ]
 6132
 6133
 6134@dataclasses.dataclass
 6135class _OmegaUp_Controllers_Contest__apiAdmins_admins_entry:
 6136    """_OmegaUp_Controllers_Contest__apiAdmins_admins_entry"""
 6137    role: str
 6138    username: str
 6139
 6140    def __init__(
 6141        self,
 6142        *,
 6143        role: str,
 6144        username: str,
 6145        # Ignore any unknown arguments
 6146        **_kwargs: Any,
 6147    ):
 6148        self.role = role
 6149        self.username = username
 6150
 6151
 6152@dataclasses.dataclass
 6153class _OmegaUp_Controllers_Contest__apiAdmins_group_admins_entry:
 6154    """_OmegaUp_Controllers_Contest__apiAdmins_group_admins_entry"""
 6155    alias: str
 6156    name: str
 6157    role: str
 6158
 6159    def __init__(
 6160        self,
 6161        *,
 6162        alias: str,
 6163        name: str,
 6164        role: str,
 6165        # Ignore any unknown arguments
 6166        **_kwargs: Any,
 6167    ):
 6168        self.alias = alias
 6169        self.name = name
 6170        self.role = role
 6171
 6172
 6173@dataclasses.dataclass
 6174class _OmegaUp_Controllers_Contest__apiClarifications:
 6175    """_OmegaUp_Controllers_Contest__apiClarifications"""
 6176    clarifications: Sequence['_Clarification']
 6177
 6178    def __init__(
 6179        self,
 6180        *,
 6181        clarifications: Sequence[Dict[str, Any]],
 6182        # Ignore any unknown arguments
 6183        **_kwargs: Any,
 6184    ):
 6185        self.clarifications = [_Clarification(**v) for v in clarifications]
 6186
 6187
 6188@dataclasses.dataclass
 6189class _OmegaUp_Controllers_Contest__apiClone:
 6190    """_OmegaUp_Controllers_Contest__apiClone"""
 6191    alias: str
 6192
 6193    def __init__(
 6194        self,
 6195        *,
 6196        alias: str,
 6197        # Ignore any unknown arguments
 6198        **_kwargs: Any,
 6199    ):
 6200        self.alias = alias
 6201
 6202
 6203@dataclasses.dataclass
 6204class _OmegaUp_Controllers_Contest__apiContestants:
 6205    """_OmegaUp_Controllers_Contest__apiContestants"""
 6206    contestants: Sequence['_Contestant']
 6207
 6208    def __init__(
 6209        self,
 6210        *,
 6211        contestants: Sequence[Dict[str, Any]],
 6212        # Ignore any unknown arguments
 6213        **_kwargs: Any,
 6214    ):
 6215        self.contestants = [_Contestant(**v) for v in contestants]
 6216
 6217
 6218@dataclasses.dataclass
 6219class _OmegaUp_Controllers_Contest__apiCreateVirtual:
 6220    """_OmegaUp_Controllers_Contest__apiCreateVirtual"""
 6221    alias: str
 6222
 6223    def __init__(
 6224        self,
 6225        *,
 6226        alias: str,
 6227        # Ignore any unknown arguments
 6228        **_kwargs: Any,
 6229    ):
 6230        self.alias = alias
 6231
 6232
 6233@dataclasses.dataclass
 6234class _OmegaUp_Controllers_Contest__apiList:
 6235    """_OmegaUp_Controllers_Contest__apiList"""
 6236    number_of_results: int
 6237    results: Sequence['_ContestListItem']
 6238
 6239    def __init__(
 6240        self,
 6241        *,
 6242        number_of_results: int,
 6243        results: Sequence[Dict[str, Any]],
 6244        # Ignore any unknown arguments
 6245        **_kwargs: Any,
 6246    ):
 6247        self.number_of_results = number_of_results
 6248        self.results = [_ContestListItem(**v) for v in results]
 6249
 6250
 6251@dataclasses.dataclass
 6252class _OmegaUp_Controllers_Contest__apiListParticipating:
 6253    """_OmegaUp_Controllers_Contest__apiListParticipating"""
 6254    contests: Sequence['_Contest']
 6255    count: int
 6256
 6257    def __init__(
 6258        self,
 6259        *,
 6260        contests: Sequence[Dict[str, Any]],
 6261        count: int,
 6262        # Ignore any unknown arguments
 6263        **_kwargs: Any,
 6264    ):
 6265        self.contests = [_Contest(**v) for v in contests]
 6266        self.count = count
 6267
 6268
 6269@dataclasses.dataclass
 6270class _OmegaUp_Controllers_Contest__apiMyList:
 6271    """_OmegaUp_Controllers_Contest__apiMyList"""
 6272    contests: Sequence['_Contest']
 6273    count: int
 6274
 6275    def __init__(
 6276        self,
 6277        *,
 6278        contests: Sequence[Dict[str, Any]],
 6279        count: int,
 6280        # Ignore any unknown arguments
 6281        **_kwargs: Any,
 6282    ):
 6283        self.contests = [_Contest(**v) for v in contests]
 6284        self.count = count
 6285
 6286
 6287@dataclasses.dataclass
 6288class _OmegaUp_Controllers_Contest__apiProblemClarifications:
 6289    """_OmegaUp_Controllers_Contest__apiProblemClarifications"""
 6290    clarifications: Sequence['_Clarification']
 6291
 6292    def __init__(
 6293        self,
 6294        *,
 6295        clarifications: Sequence[Dict[str, Any]],
 6296        # Ignore any unknown arguments
 6297        **_kwargs: Any,
 6298    ):
 6299        self.clarifications = [_Clarification(**v) for v in clarifications]
 6300
 6301
 6302@dataclasses.dataclass
 6303class _OmegaUp_Controllers_Contest__apiProblems:
 6304    """_OmegaUp_Controllers_Contest__apiProblems"""
 6305    problems: Sequence['_ProblemsetProblemWithVersions']
 6306
 6307    def __init__(
 6308        self,
 6309        *,
 6310        problems: Sequence[Dict[str, Any]],
 6311        # Ignore any unknown arguments
 6312        **_kwargs: Any,
 6313    ):
 6314        self.problems = [_ProblemsetProblemWithVersions(**v) for v in problems]
 6315
 6316
 6317@dataclasses.dataclass
 6318class _OmegaUp_Controllers_Contest__apiReport:
 6319    """_OmegaUp_Controllers_Contest__apiReport"""
 6320    finish_time: Optional[datetime.datetime]
 6321    problems: Sequence[
 6322        '_OmegaUp_Controllers_Contest__apiReport_problems_entry']
 6323    ranking: Sequence['_ContestReport']
 6324    start_time: datetime.datetime
 6325    time: datetime.datetime
 6326    title: str
 6327
 6328    def __init__(
 6329        self,
 6330        *,
 6331        problems: Sequence[Dict[str, Any]],
 6332        ranking: Sequence[Dict[str, Any]],
 6333        start_time: int,
 6334        time: int,
 6335        title: str,
 6336        finish_time: Optional[int] = None,
 6337        # Ignore any unknown arguments
 6338        **_kwargs: Any,
 6339    ):
 6340        if finish_time is not None:
 6341            self.finish_time = datetime.datetime.fromtimestamp(finish_time)
 6342        else:
 6343            self.finish_time = None
 6344        self.problems = [
 6345            _OmegaUp_Controllers_Contest__apiReport_problems_entry(**v)
 6346            for v in problems
 6347        ]
 6348        self.ranking = [_ContestReport(**v) for v in ranking]
 6349        self.start_time = datetime.datetime.fromtimestamp(start_time)
 6350        self.time = datetime.datetime.fromtimestamp(time)
 6351        self.title = title
 6352
 6353
 6354@dataclasses.dataclass
 6355class _OmegaUp_Controllers_Contest__apiReport_problems_entry:
 6356    """_OmegaUp_Controllers_Contest__apiReport_problems_entry"""
 6357    alias: str
 6358    order: int
 6359
 6360    def __init__(
 6361        self,
 6362        *,
 6363        alias: str,
 6364        order: int,
 6365        # Ignore any unknown arguments
 6366        **_kwargs: Any,
 6367    ):
 6368        self.alias = alias
 6369        self.order = order
 6370
 6371
 6372@dataclasses.dataclass
 6373class _OmegaUp_Controllers_Contest__apiRequests:
 6374    """_OmegaUp_Controllers_Contest__apiRequests"""
 6375    contest_alias: str
 6376    users: Sequence['_OmegaUp_Controllers_Contest__apiRequests_users_entry']
 6377
 6378    def __init__(
 6379        self,
 6380        *,
 6381        contest_alias: str,
 6382        users: Sequence[Dict[str, Any]],
 6383        # Ignore any unknown arguments
 6384        **_kwargs: Any,
 6385    ):
 6386        self.contest_alias = contest_alias
 6387        self.users = [
 6388            _OmegaUp_Controllers_Contest__apiRequests_users_entry(**v)
 6389            for v in users
 6390        ]
 6391
 6392
 6393@dataclasses.dataclass
 6394class _OmegaUp_Controllers_Contest__apiRequests_users_entry:
 6395    """_OmegaUp_Controllers_Contest__apiRequests_users_entry"""
 6396    accepted: bool
 6397    admin: Optional[
 6398        '_OmegaUp_Controllers_Contest__apiRequests_users_entry_admin']
 6399    country: str
 6400    last_update: datetime.datetime
 6401    request_time: datetime.datetime
 6402    username: str
 6403
 6404    def __init__(
 6405        self,
 6406        *,
 6407        accepted: bool,
 6408        country: str,
 6409        last_update: int,
 6410        request_time: int,
 6411        username: str,
 6412        admin: Optional[Dict[str, Any]] = None,
 6413        # Ignore any unknown arguments
 6414        **_kwargs: Any,
 6415    ):
 6416        self.accepted = accepted
 6417        if admin is not None:
 6418            self.admin = _OmegaUp_Controllers_Contest__apiRequests_users_entry_admin(
 6419                **admin)
 6420        else:
 6421            self.admin = None
 6422        self.country = country
 6423        self.last_update = datetime.datetime.fromtimestamp(last_update)
 6424        self.request_time = datetime.datetime.fromtimestamp(request_time)
 6425        self.username = username
 6426
 6427
 6428@dataclasses.dataclass
 6429class _OmegaUp_Controllers_Contest__apiRequests_users_entry_admin:
 6430    """_OmegaUp_Controllers_Contest__apiRequests_users_entry_admin"""
 6431    username: Optional[str]
 6432
 6433    def __init__(
 6434        self,
 6435        *,
 6436        username: Optional[str] = None,
 6437        # Ignore any unknown arguments
 6438        **_kwargs: Any,
 6439    ):
 6440        if username is not None:
 6441            self.username = username
 6442        else:
 6443            self.username = None
 6444
 6445
 6446@dataclasses.dataclass
 6447class _OmegaUp_Controllers_Contest__apiRole:
 6448    """_OmegaUp_Controllers_Contest__apiRole"""
 6449    admin: bool
 6450
 6451    def __init__(
 6452        self,
 6453        *,
 6454        admin: bool,
 6455        # Ignore any unknown arguments
 6456        **_kwargs: Any,
 6457    ):
 6458        self.admin = admin
 6459
 6460
 6461@dataclasses.dataclass
 6462class _OmegaUp_Controllers_Contest__apiRuns:
 6463    """_OmegaUp_Controllers_Contest__apiRuns"""
 6464    runs: Sequence['_Run']
 6465    totalRuns: int
 6466
 6467    def __init__(
 6468        self,
 6469        *,
 6470        runs: Sequence[Dict[str, Any]],
 6471        totalRuns: int,
 6472        # Ignore any unknown arguments
 6473        **_kwargs: Any,
 6474    ):
 6475        self.runs = [_Run(**v) for v in runs]
 6476        self.totalRuns = totalRuns
 6477
 6478
 6479@dataclasses.dataclass
 6480class _OmegaUp_Controllers_Contest__apiRunsDiff:
 6481    """_OmegaUp_Controllers_Contest__apiRunsDiff"""
 6482    diff: Sequence['_OmegaUp_Controllers_Contest__apiRunsDiff_diff_entry']
 6483
 6484    def __init__(
 6485        self,
 6486        *,
 6487        diff: Sequence[Dict[str, Any]],
 6488        # Ignore any unknown arguments
 6489        **_kwargs: Any,
 6490    ):
 6491        self.diff = [
 6492            _OmegaUp_Controllers_Contest__apiRunsDiff_diff_entry(**v)
 6493            for v in diff
 6494        ]
 6495
 6496
 6497@dataclasses.dataclass
 6498class _OmegaUp_Controllers_Contest__apiRunsDiff_diff_entry:
 6499    """_OmegaUp_Controllers_Contest__apiRunsDiff_diff_entry"""
 6500    guid: str
 6501    new_score: float
 6502    new_status: str
 6503    new_verdict: str
 6504    old_score: float
 6505    old_status: str
 6506    old_verdict: str
 6507    problemset_id: int
 6508    username: str
 6509
 6510    def __init__(
 6511        self,
 6512        *,
 6513        guid: str,
 6514        new_score: float,
 6515        new_status: str,
 6516        new_verdict: str,
 6517        old_score: float,
 6518        old_status: str,
 6519        old_verdict: str,
 6520        problemset_id: int,
 6521        username: str,
 6522        # Ignore any unknown arguments
 6523        **_kwargs: Any,
 6524    ):
 6525        self.guid = guid
 6526        self.new_score = new_score
 6527        self.new_status = new_status
 6528        self.new_verdict = new_verdict
 6529        self.old_score = old_score
 6530        self.old_status = old_status
 6531        self.old_verdict = old_verdict
 6532        self.problemset_id = problemset_id
 6533        self.username = username
 6534
 6535
 6536@dataclasses.dataclass
 6537class _OmegaUp_Controllers_Contest__apiScoreboardEvents:
 6538    """_OmegaUp_Controllers_Contest__apiScoreboardEvents"""
 6539    events: Sequence['_ScoreboardEvent']
 6540
 6541    def __init__(
 6542        self,
 6543        *,
 6544        events: Sequence[Dict[str, Any]],
 6545        # Ignore any unknown arguments
 6546        **_kwargs: Any,
 6547    ):
 6548        self.events = [_ScoreboardEvent(**v) for v in events]
 6549
 6550
 6551@dataclasses.dataclass
 6552class _OmegaUp_Controllers_Contest__apiScoreboardMerge:
 6553    """_OmegaUp_Controllers_Contest__apiScoreboardMerge"""
 6554    ranking: Sequence['_MergedScoreboardEntry']
 6555
 6556    def __init__(
 6557        self,
 6558        *,
 6559        ranking: Sequence[Dict[str, Any]],
 6560        # Ignore any unknown arguments
 6561        **_kwargs: Any,
 6562    ):
 6563        self.ranking = [_MergedScoreboardEntry(**v) for v in ranking]
 6564
 6565
 6566@dataclasses.dataclass
 6567class _OmegaUp_Controllers_Contest__apiSearchUsers:
 6568    """_OmegaUp_Controllers_Contest__apiSearchUsers"""
 6569    results: Sequence['_ListItem']
 6570
 6571    def __init__(
 6572        self,
 6573        *,
 6574        results: Sequence[Dict[str, Any]],
 6575        # Ignore any unknown arguments
 6576        **_kwargs: Any,
 6577    ):
 6578        self.results = [_ListItem(**v) for v in results]
 6579
 6580
 6581@dataclasses.dataclass
 6582class _OmegaUp_Controllers_Contest__apiStats:
 6583    """_OmegaUp_Controllers_Contest__apiStats"""
 6584    distribution: Dict[int, int]
 6585    max_wait_time: Optional[datetime.datetime]
 6586    max_wait_time_guid: Optional[str]
 6587    pending_runs: Sequence[str]
 6588    size_of_bucket: float
 6589    total_points: float
 6590    total_runs: int
 6591    verdict_counts: Dict[str, int]
 6592
 6593    def __init__(
 6594        self,
 6595        *,
 6596        distribution: Dict[int, int],
 6597        pending_runs: Sequence[str],
 6598        size_of_bucket: float,
 6599        total_points: float,
 6600        total_runs: int,
 6601        verdict_counts: Dict[str, int],
 6602        max_wait_time: Optional[int] = None,
 6603        max_wait_time_guid: Optional[str] = None,
 6604        # Ignore any unknown arguments
 6605        **_kwargs: Any,
 6606    ):
 6607        self.distribution = {k: v for k, v in distribution.items()}
 6608        if max_wait_time is not None:
 6609            self.max_wait_time = datetime.datetime.fromtimestamp(max_wait_time)
 6610        else:
 6611            self.max_wait_time = None
 6612        if max_wait_time_guid is not None:
 6613            self.max_wait_time_guid = max_wait_time_guid
 6614        else:
 6615            self.max_wait_time_guid = None
 6616        self.pending_runs = [v for v in pending_runs]
 6617        self.size_of_bucket = size_of_bucket
 6618        self.total_points = total_points
 6619        self.total_runs = total_runs
 6620        self.verdict_counts = {k: v for k, v in verdict_counts.items()}
 6621
 6622
 6623@dataclasses.dataclass
 6624class _OmegaUp_Controllers_Contest__apiUpdate:
 6625    """_OmegaUp_Controllers_Contest__apiUpdate"""
 6626    teamsGroupName: Optional[str]
 6627    title: str
 6628
 6629    def __init__(
 6630        self,
 6631        *,
 6632        title: str,
 6633        teamsGroupName: Optional[str] = None,
 6634        # Ignore any unknown arguments
 6635        **_kwargs: Any,
 6636    ):
 6637        if teamsGroupName is not None:
 6638            self.teamsGroupName = teamsGroupName
 6639        else:
 6640            self.teamsGroupName = None
 6641        self.title = title
 6642
 6643
 6644@dataclasses.dataclass
 6645class _OmegaUp_Controllers_Contest__apiUsers:
 6646    """_OmegaUp_Controllers_Contest__apiUsers"""
 6647    groups: Sequence['_OmegaUp_Controllers_Contest__apiUsers_groups_entry']
 6648    users: Sequence['_ContestUser']
 6649
 6650    def __init__(
 6651        self,
 6652        *,
 6653        groups: Sequence[Dict[str, Any]],
 6654        users: Sequence[Dict[str, Any]],
 6655        # Ignore any unknown arguments
 6656        **_kwargs: Any,
 6657    ):
 6658        self.groups = [
 6659            _OmegaUp_Controllers_Contest__apiUsers_groups_entry(**v)
 6660            for v in groups
 6661        ]
 6662        self.users = [_ContestUser(**v) for v in users]
 6663
 6664
 6665@dataclasses.dataclass
 6666class _OmegaUp_Controllers_Contest__apiUsers_groups_entry:
 6667    """_OmegaUp_Controllers_Contest__apiUsers_groups_entry"""
 6668    alias: str
 6669    name: str
 6670
 6671    def __init__(
 6672        self,
 6673        *,
 6674        alias: str,
 6675        name: str,
 6676        # Ignore any unknown arguments
 6677        **_kwargs: Any,
 6678    ):
 6679        self.alias = alias
 6680        self.name = name
 6681
 6682
 6683@dataclasses.dataclass
 6684class _OmegaUp_Controllers_Course__apiActivityReport:
 6685    """_OmegaUp_Controllers_Course__apiActivityReport"""
 6686    events: Sequence['_ActivityEvent']
 6687    pagerItems: Sequence['_PageItem']
 6688
 6689    def __init__(
 6690        self,
 6691        *,
 6692        events: Sequence[Dict[str, Any]],
 6693        pagerItems: Sequence[Dict[str, Any]],
 6694        # Ignore any unknown arguments
 6695        **_kwargs: Any,
 6696    ):
 6697        self.events = [_ActivityEvent(**v) for v in events]
 6698        self.pagerItems = [_PageItem(**v) for v in pagerItems]
 6699
 6700
 6701@dataclasses.dataclass
 6702class _OmegaUp_Controllers_Course__apiAdmins:
 6703    """_OmegaUp_Controllers_Course__apiAdmins"""
 6704    admins: Sequence['_OmegaUp_Controllers_Course__apiAdmins_admins_entry']
 6705    group_admins: Sequence[
 6706        '_OmegaUp_Controllers_Course__apiAdmins_group_admins_entry']
 6707    group_teaching_assistants: Sequence[
 6708        '_OmegaUp_Controllers_Course__apiAdmins_group_teaching_assistants_entry']
 6709    teaching_assistants: Sequence[
 6710        '_OmegaUp_Controllers_Course__apiAdmins_teaching_assistants_entry']
 6711
 6712    def __init__(
 6713        self,
 6714        *,
 6715        admins: Sequence[Dict[str, Any]],
 6716        group_admins: Sequence[Dict[str, Any]],
 6717        group_teaching_assistants: Sequence[Dict[str, Any]],
 6718        teaching_assistants: Sequence[Dict[str, Any]],
 6719        # Ignore any unknown arguments
 6720        **_kwargs: Any,
 6721    ):
 6722        self.admins = [
 6723            _OmegaUp_Controllers_Course__apiAdmins_admins_entry(**v)
 6724            for v in admins
 6725        ]
 6726        self.group_admins = [
 6727            _OmegaUp_Controllers_Course__apiAdmins_group_admins_entry(**v)
 6728            for v in group_admins
 6729        ]
 6730        self.group_teaching_assistants = [
 6731            _OmegaUp_Controllers_Course__apiAdmins_group_teaching_assistants_entry(
 6732                **v) for v in group_teaching_assistants
 6733        ]
 6734        self.teaching_assistants = [
 6735            _OmegaUp_Controllers_Course__apiAdmins_teaching_assistants_entry(
 6736                **v) for v in teaching_assistants
 6737        ]
 6738
 6739
 6740@dataclasses.dataclass
 6741class _OmegaUp_Controllers_Course__apiAdmins_admins_entry:
 6742    """_OmegaUp_Controllers_Course__apiAdmins_admins_entry"""
 6743    role: str
 6744    username: str
 6745
 6746    def __init__(
 6747        self,
 6748        *,
 6749        role: str,
 6750        username: str,
 6751        # Ignore any unknown arguments
 6752        **_kwargs: Any,
 6753    ):
 6754        self.role = role
 6755        self.username = username
 6756
 6757
 6758@dataclasses.dataclass
 6759class _OmegaUp_Controllers_Course__apiAdmins_group_admins_entry:
 6760    """_OmegaUp_Controllers_Course__apiAdmins_group_admins_entry"""
 6761    alias: str
 6762    name: str
 6763    role: str
 6764
 6765    def __init__(
 6766        self,
 6767        *,
 6768        alias: str,
 6769        name: str,
 6770        role: str,
 6771        # Ignore any unknown arguments
 6772        **_kwargs: Any,
 6773    ):
 6774        self.alias = alias
 6775        self.name = name
 6776        self.role = role
 6777
 6778
 6779@dataclasses.dataclass
 6780class _OmegaUp_Controllers_Course__apiAdmins_group_teaching_assistants_entry:
 6781    """_OmegaUp_Controllers_Course__apiAdmins_group_teaching_assistants_entry"""
 6782    alias: str
 6783    name: str
 6784    role: str
 6785
 6786    def __init__(
 6787        self,
 6788        *,
 6789        alias: str,
 6790        name: str,
 6791        role: str,
 6792        # Ignore any unknown arguments
 6793        **_kwargs: Any,
 6794    ):
 6795        self.alias = alias
 6796        self.name = name
 6797        self.role = role
 6798
 6799
 6800@dataclasses.dataclass
 6801class _OmegaUp_Controllers_Course__apiAdmins_teaching_assistants_entry:
 6802    """_OmegaUp_Controllers_Course__apiAdmins_teaching_assistants_entry"""
 6803    role: str
 6804    username: str
 6805
 6806    def __init__(
 6807        self,
 6808        *,
 6809        role: str,
 6810        username: str,
 6811        # Ignore any unknown arguments
 6812        **_kwargs: Any,
 6813    ):
 6814        self.role = role
 6815        self.username = username
 6816
 6817
 6818@dataclasses.dataclass
 6819class _OmegaUp_Controllers_Course__apiAssignmentDetails:
 6820    """_OmegaUp_Controllers_Course__apiAssignmentDetails"""
 6821    admin: bool
 6822    alias: str
 6823    assignment_type: Optional[str]
 6824    courseAssignments: Sequence['_CourseAssignment']
 6825    description: Optional[str]
 6826    director: str
 6827    finish_time: Optional[datetime.datetime]
 6828    name: str
 6829    problems: Sequence['_ProblemsetProblem']
 6830    problemset_id: int
 6831    start_time: datetime.datetime
 6832
 6833    def __init__(
 6834        self,
 6835        *,
 6836        admin: bool,
 6837        alias: str,
 6838        courseAssignments: Sequence[Dict[str, Any]],
 6839        director: str,
 6840        name: str,
 6841        problems: Sequence[Dict[str, Any]],
 6842        problemset_id: int,
 6843        start_time: int,
 6844        assignment_type: Optional[str] = None,
 6845        description: Optional[str] = None,
 6846        finish_time: Optional[int] = None,
 6847        # Ignore any unknown arguments
 6848        **_kwargs: Any,
 6849    ):
 6850        self.admin = admin
 6851        self.alias = alias
 6852        if assignment_type is not None:
 6853            self.assignment_type = assignment_type
 6854        else:
 6855            self.assignment_type = None
 6856        self.courseAssignments = [
 6857            _CourseAssignment(**v) for v in courseAssignments
 6858        ]
 6859        if description is not None:
 6860            self.description = description
 6861        else:
 6862            self.description = None
 6863        self.director = director
 6864        if finish_time is not None:
 6865            self.finish_time = datetime.datetime.fromtimestamp(finish_time)
 6866        else:
 6867            self.finish_time = None
 6868        self.name = name
 6869        self.problems = [_ProblemsetProblem(**v) for v in problems]
 6870        self.problemset_id = problemset_id
 6871        self.start_time = datetime.datetime.fromtimestamp(start_time)
 6872
 6873
 6874@dataclasses.dataclass
 6875class _OmegaUp_Controllers_Course__apiAssignmentScoreboardEvents:
 6876    """_OmegaUp_Controllers_Course__apiAssignmentScoreboardEvents"""
 6877    events: Sequence['_ScoreboardEvent']
 6878
 6879    def __init__(
 6880        self,
 6881        *,
 6882        events: Sequence[Dict[str, Any]],
 6883        # Ignore any unknown arguments
 6884        **_kwargs: Any,
 6885    ):
 6886        self.events = [_ScoreboardEvent(**v) for v in events]
 6887
 6888
 6889@dataclasses.dataclass
 6890class _OmegaUp_Controllers_Course__apiClarifications:
 6891    """_OmegaUp_Controllers_Course__apiClarifications"""
 6892    clarifications: Sequence['_Clarification']
 6893
 6894    def __init__(
 6895        self,
 6896        *,
 6897        clarifications: Sequence[Dict[str, Any]],
 6898        # Ignore any unknown arguments
 6899        **_kwargs: Any,
 6900    ):
 6901        self.clarifications = [_Clarification(**v) for v in clarifications]
 6902
 6903
 6904@dataclasses.dataclass
 6905class _OmegaUp_Controllers_Course__apiClone:
 6906    """_OmegaUp_Controllers_Course__apiClone"""
 6907    alias: str
 6908
 6909    def __init__(
 6910        self,
 6911        *,
 6912        alias: str,
 6913        # Ignore any unknown arguments
 6914        **_kwargs: Any,
 6915    ):
 6916        self.alias = alias
 6917
 6918
 6919@dataclasses.dataclass
 6920class _OmegaUp_Controllers_Course__apiGenerateTokenForCloneCourse:
 6921    """_OmegaUp_Controllers_Course__apiGenerateTokenForCloneCourse"""
 6922    token: str
 6923
 6924    def __init__(
 6925        self,
 6926        *,
 6927        token: str,
 6928        # Ignore any unknown arguments
 6929        **_kwargs: Any,
 6930    ):
 6931        self.token = token
 6932
 6933
 6934@dataclasses.dataclass
 6935class _OmegaUp_Controllers_Course__apiGetProblemUsers:
 6936    """_OmegaUp_Controllers_Course__apiGetProblemUsers"""
 6937    identities: Sequence[str]
 6938
 6939    def __init__(
 6940        self,
 6941        *,
 6942        identities: Sequence[str],
 6943        # Ignore any unknown arguments
 6944        **_kwargs: Any,
 6945    ):
 6946        self.identities = [v for v in identities]
 6947
 6948
 6949@dataclasses.dataclass
 6950class _OmegaUp_Controllers_Course__apiListAssignments:
 6951    """_OmegaUp_Controllers_Course__apiListAssignments"""
 6952    assignments: Sequence['_CourseAssignment']
 6953
 6954    def __init__(
 6955        self,
 6956        *,
 6957        assignments: Sequence[Dict[str, Any]],
 6958        # Ignore any unknown arguments
 6959        **_kwargs: Any,
 6960    ):
 6961        self.assignments = [_CourseAssignment(**v) for v in assignments]
 6962
 6963
 6964@dataclasses.dataclass
 6965class _OmegaUp_Controllers_Course__apiListSolvedProblems:
 6966    """_OmegaUp_Controllers_Course__apiListSolvedProblems"""
 6967    user_problems: Dict[str, Sequence[
 6968        '_OmegaUp_Controllers_Course__apiListSolvedProblems_user_problems_value_entry']]
 6969
 6970    def __init__(
 6971        self,
 6972        *,
 6973        user_problems: Dict[str, Sequence[Dict[str, Any]]],
 6974        # Ignore any unknown arguments
 6975        **_kwargs: Any,
 6976    ):
 6977        self.user_problems = {
 6978            k: [
 6979                _OmegaUp_Controllers_Course__apiListSolvedProblems_user_problems_value_entry(
 6980                    **v) for v in v
 6981            ]
 6982            for k, v in user_problems.items()
 6983        }
 6984
 6985
 6986@dataclasses.dataclass
 6987class _OmegaUp_Controllers_Course__apiListSolvedProblems_user_problems_value_entry:
 6988    """_OmegaUp_Controllers_Course__apiListSolvedProblems_user_problems_value_entry"""
 6989    alias: str
 6990    title: str
 6991    username: str
 6992
 6993    def __init__(
 6994        self,
 6995        *,
 6996        alias: str,
 6997        title: str,
 6998        username: str,
 6999        # Ignore any unknown arguments
 7000        **_kwargs: Any,
 7001    ):
 7002        self.alias = alias
 7003        self.title = title
 7004        self.username = username
 7005
 7006
 7007@dataclasses.dataclass
 7008class _OmegaUp_Controllers_Course__apiListStudents:
 7009    """_OmegaUp_Controllers_Course__apiListStudents"""
 7010    students: Sequence['_CourseStudent']
 7011
 7012    def __init__(
 7013        self,
 7014        *,
 7015        students: Sequence[Dict[str, Any]],
 7016        # Ignore any unknown arguments
 7017        **_kwargs: Any,
 7018    ):
 7019        self.students = [_CourseStudent(**v) for v in students]
 7020
 7021
 7022@dataclasses.dataclass
 7023class _OmegaUp_Controllers_Course__apiListUnsolvedProblems:
 7024    """_OmegaUp_Controllers_Course__apiListUnsolvedProblems"""
 7025    user_problems: Dict[str, Sequence[
 7026        '_OmegaUp_Controllers_Course__apiListUnsolvedProblems_user_problems_value_entry']]
 7027
 7028    def __init__(
 7029        self,
 7030        *,
 7031        user_problems: Dict[str, Sequence[Dict[str, Any]]],
 7032        # Ignore any unknown arguments
 7033        **_kwargs: Any,
 7034    ):
 7035        self.user_problems = {
 7036            k: [
 7037                _OmegaUp_Controllers_Course__apiListUnsolvedProblems_user_problems_value_entry(
 7038                    **v) for v in v
 7039            ]
 7040            for k, v in user_problems.items()
 7041        }
 7042
 7043
 7044@dataclasses.dataclass
 7045class _OmegaUp_Controllers_Course__apiListUnsolvedProblems_user_problems_value_entry:
 7046    """_OmegaUp_Controllers_Course__apiListUnsolvedProblems_user_problems_value_entry"""
 7047    alias: str
 7048    title: str
 7049    username: str
 7050
 7051    def __init__(
 7052        self,
 7053        *,
 7054        alias: str,
 7055        title: str,
 7056        username: str,
 7057        # Ignore any unknown arguments
 7058        **_kwargs: Any,
 7059    ):
 7060        self.alias = alias
 7061        self.title = title
 7062        self.username = username
 7063
 7064
 7065@dataclasses.dataclass
 7066class _OmegaUp_Controllers_Course__apiMyProgress:
 7067    """_OmegaUp_Controllers_Course__apiMyProgress"""
 7068    assignments: Dict[str, '_Progress']
 7069
 7070    def __init__(
 7071        self,
 7072        *,
 7073        assignments: Dict[str, Dict[str, Any]],
 7074        # Ignore any unknown arguments
 7075        **_kwargs: Any,
 7076    ):
 7077        self.assignments = {k: _Progress(**v) for k, v in assignments.items()}
 7078
 7079
 7080@dataclasses.dataclass
 7081class _OmegaUp_Controllers_Course__apiProblemClarifications:
 7082    """_OmegaUp_Controllers_Course__apiProblemClarifications"""
 7083    clarifications: Sequence['_Clarification']
 7084
 7085    def __init__(
 7086        self,
 7087        *,
 7088        clarifications: Sequence[Dict[str, Any]],
 7089        # Ignore any unknown arguments
 7090        **_kwargs: Any,
 7091    ):
 7092        self.clarifications = [_Clarification(**v) for v in clarifications]
 7093
 7094
 7095@dataclasses.dataclass
 7096class _OmegaUp_Controllers_Course__apiRequests:
 7097    """_OmegaUp_Controllers_Course__apiRequests"""
 7098    users: Sequence['_IdentityRequest']
 7099
 7100    def __init__(
 7101        self,
 7102        *,
 7103        users: Sequence[Dict[str, Any]],
 7104        # Ignore any unknown arguments
 7105        **_kwargs: Any,
 7106    ):
 7107        self.users = [_IdentityRequest(**v) for v in users]
 7108
 7109
 7110@dataclasses.dataclass
 7111class _OmegaUp_Controllers_Course__apiRuns:
 7112    """_OmegaUp_Controllers_Course__apiRuns"""
 7113    runs: Sequence['_Run']
 7114    totalRuns: int
 7115
 7116    def __init__(
 7117        self,
 7118        *,
 7119        runs: Sequence[Dict[str, Any]],
 7120        totalRuns: int,
 7121        # Ignore any unknown arguments
 7122        **_kwargs: Any,
 7123    ):
 7124        self.runs = [_Run(**v) for v in runs]
 7125        self.totalRuns = totalRuns
 7126
 7127
 7128@dataclasses.dataclass
 7129class _OmegaUp_Controllers_Course__apiSearchUsers:
 7130    """_OmegaUp_Controllers_Course__apiSearchUsers"""
 7131    results: Sequence['_ListItem']
 7132
 7133    def __init__(
 7134        self,
 7135        *,
 7136        results: Sequence[Dict[str, Any]],
 7137        # Ignore any unknown arguments
 7138        **_kwargs: Any,
 7139    ):
 7140        self.results = [_ListItem(**v) for v in results]
 7141
 7142
 7143@dataclasses.dataclass
 7144class _OmegaUp_Controllers_Course__apiStudentProgress:
 7145    """_OmegaUp_Controllers_Course__apiStudentProgress"""
 7146    problems: Sequence['_CourseProblem']
 7147
 7148    def __init__(
 7149        self,
 7150        *,
 7151        problems: Sequence[Dict[str, Any]],
 7152        # Ignore any unknown arguments
 7153        **_kwargs: Any,
 7154    ):
 7155        self.problems = [_CourseProblem(**v) for v in problems]
 7156
 7157
 7158@dataclasses.dataclass
 7159class _OmegaUp_Controllers_Course__apiStudentsProgress:
 7160    """_OmegaUp_Controllers_Course__apiStudentsProgress"""
 7161    nextPage: Optional[int]
 7162    progress: Sequence['_StudentProgressInCourse']
 7163
 7164    def __init__(
 7165        self,
 7166        *,
 7167        progress: Sequence[Dict[str, Any]],
 7168        nextPage: Optional[int] = None,
 7169        # Ignore any unknown arguments
 7170        **_kwargs: Any,
 7171    ):
 7172        if nextPage is not None:
 7173            self.nextPage = nextPage
 7174        else:
 7175            self.nextPage = None
 7176        self.progress = [_StudentProgressInCourse(**v) for v in progress]
 7177
 7178
 7179@dataclasses.dataclass
 7180class _OmegaUp_Controllers_Grader__apiStatus:
 7181    """_OmegaUp_Controllers_Grader__apiStatus"""
 7182    grader: '_GraderStatus'
 7183
 7184    def __init__(
 7185        self,
 7186        *,
 7187        grader: Dict[str, Any],
 7188        # Ignore any unknown arguments
 7189        **_kwargs: Any,
 7190    ):
 7191        self.grader = _GraderStatus(**grader)
 7192
 7193
 7194@dataclasses.dataclass
 7195class _OmegaUp_Controllers_GroupScoreboard__apiList:
 7196    """_OmegaUp_Controllers_GroupScoreboard__apiList"""
 7197    scoreboards: Sequence[
 7198        '_OmegaUp_Controllers_GroupScoreboard__apiList_scoreboards_entry']
 7199
 7200    def __init__(
 7201        self,
 7202        *,
 7203        scoreboards: Sequence[Dict[str, Any]],
 7204        # Ignore any unknown arguments
 7205        **_kwargs: Any,
 7206    ):
 7207        self.scoreboards = [
 7208            _OmegaUp_Controllers_GroupScoreboard__apiList_scoreboards_entry(
 7209                **v) for v in scoreboards
 7210        ]
 7211
 7212
 7213@dataclasses.dataclass
 7214class _OmegaUp_Controllers_GroupScoreboard__apiList_scoreboards_entry:
 7215    """_OmegaUp_Controllers_GroupScoreboard__apiList_scoreboards_entry"""
 7216    alias: str
 7217    create_time: int
 7218    description: str
 7219    group_id: int
 7220    group_scoreboard_id: int
 7221    name: str
 7222
 7223    def __init__(
 7224        self,
 7225        *,
 7226        alias: str,
 7227        create_time: int,
 7228        description: str,
 7229        group_id: int,
 7230        group_scoreboard_id: int,
 7231        name: str,
 7232        # Ignore any unknown arguments
 7233        **_kwargs: Any,
 7234    ):
 7235        self.alias = alias
 7236        self.create_time = create_time
 7237        self.description = description
 7238        self.group_id = group_id
 7239        self.group_scoreboard_id = group_scoreboard_id
 7240        self.name = name
 7241
 7242
 7243@dataclasses.dataclass
 7244class _OmegaUp_Controllers_Group__apiDetails:
 7245    """_OmegaUp_Controllers_Group__apiDetails"""
 7246    group: '_OmegaUp_Controllers_Group__apiDetails_group'
 7247    scoreboards: Sequence['_GroupScoreboard']
 7248
 7249    def __init__(
 7250        self,
 7251        *,
 7252        group: Dict[str, Any],
 7253        scoreboards: Sequence[Dict[str, Any]],
 7254        # Ignore any unknown arguments
 7255        **_kwargs: Any,
 7256    ):
 7257        self.group = _OmegaUp_Controllers_Group__apiDetails_group(**group)
 7258        self.scoreboards = [_GroupScoreboard(**v) for v in scoreboards]
 7259
 7260
 7261@dataclasses.dataclass
 7262class _OmegaUp_Controllers_Group__apiDetails_group:
 7263    """_OmegaUp_Controllers_Group__apiDetails_group"""
 7264    alias: str
 7265    create_time: int
 7266    description: str
 7267    name: str
 7268
 7269    def __init__(
 7270        self,
 7271        *,
 7272        alias: str,
 7273        create_time: int,
 7274        description: str,
 7275        name: str,
 7276        # Ignore any unknown arguments
 7277        **_kwargs: Any,
 7278    ):
 7279        self.alias = alias
 7280        self.create_time = create_time
 7281        self.description = description
 7282        self.name = name
 7283
 7284
 7285@dataclasses.dataclass
 7286class _OmegaUp_Controllers_Group__apiMembers:
 7287    """_OmegaUp_Controllers_Group__apiMembers"""
 7288    identities: Sequence['_Identity']
 7289
 7290    def __init__(
 7291        self,
 7292        *,
 7293        identities: Sequence[Dict[str, Any]],
 7294        # Ignore any unknown arguments
 7295        **_kwargs: Any,
 7296    ):
 7297        self.identities = [_Identity(**v) for v in identities]
 7298
 7299
 7300@dataclasses.dataclass
 7301class _OmegaUp_Controllers_Group__apiMyList:
 7302    """_OmegaUp_Controllers_Group__apiMyList"""
 7303    groups: Sequence['_OmegaUp_Controllers_Group__apiMyList_groups_entry']
 7304
 7305    def __init__(
 7306        self,
 7307        *,
 7308        groups: Sequence[Dict[str, Any]],
 7309        # Ignore any unknown arguments
 7310        **_kwargs: Any,
 7311    ):
 7312        self.groups = [
 7313            _OmegaUp_Controllers_Group__apiMyList_groups_entry(**v)
 7314            for v in groups
 7315        ]
 7316
 7317
 7318@dataclasses.dataclass
 7319class _OmegaUp_Controllers_Group__apiMyList_groups_entry:
 7320    """_OmegaUp_Controllers_Group__apiMyList_groups_entry"""
 7321    alias: str
 7322    create_time: datetime.datetime
 7323    description: str
 7324    name: str
 7325
 7326    def __init__(
 7327        self,
 7328        *,
 7329        alias: str,
 7330        create_time: int,
 7331        description: str,
 7332        name: str,
 7333        # Ignore any unknown arguments
 7334        **_kwargs: Any,
 7335    ):
 7336        self.alias = alias
 7337        self.create_time = datetime.datetime.fromtimestamp(create_time)
 7338        self.description = description
 7339        self.name = name
 7340
 7341
 7342@dataclasses.dataclass
 7343class _OmegaUp_Controllers_Identity__apiCreate:
 7344    """_OmegaUp_Controllers_Identity__apiCreate"""
 7345    username: str
 7346
 7347    def __init__(
 7348        self,
 7349        *,
 7350        username: str,
 7351        # Ignore any unknown arguments
 7352        **_kwargs: Any,
 7353    ):
 7354        self.username = username
 7355
 7356
 7357@dataclasses.dataclass
 7358class _OmegaUp_Controllers_Notification__apiMyList:
 7359    """_OmegaUp_Controllers_Notification__apiMyList"""
 7360    notifications: Sequence['_Notification']
 7361
 7362    def __init__(
 7363        self,
 7364        *,
 7365        notifications: Sequence[Dict[str, Any]],
 7366        # Ignore any unknown arguments
 7367        **_kwargs: Any,
 7368    ):
 7369        self.notifications = [_Notification(**v) for v in notifications]
 7370
 7371
 7372@dataclasses.dataclass
 7373class _OmegaUp_Controllers_ProblemForfeited__apiGetCounts:
 7374    """_OmegaUp_Controllers_ProblemForfeited__apiGetCounts"""
 7375    allowed: int
 7376    seen: int
 7377
 7378    def __init__(
 7379        self,
 7380        *,
 7381        allowed: int,
 7382        seen: int,
 7383        # Ignore any unknown arguments
 7384        **_kwargs: Any,
 7385    ):
 7386        self.allowed = allowed
 7387        self.seen = seen
 7388
 7389
 7390@dataclasses.dataclass
 7391class _OmegaUp_Controllers_Problem__apiAddTag:
 7392    """_OmegaUp_Controllers_Problem__apiAddTag"""
 7393    name: str
 7394
 7395    def __init__(
 7396        self,
 7397        *,
 7398        name: str,
 7399        # Ignore any unknown arguments
 7400        **_kwargs: Any,
 7401    ):
 7402        self.name = name
 7403
 7404
 7405@dataclasses.dataclass
 7406class _OmegaUp_Controllers_Problem__apiAdminList:
 7407    """_OmegaUp_Controllers_Problem__apiAdminList"""
 7408    pagerItems: Sequence['_PageItem']
 7409    problems: Sequence['_ProblemListItem']
 7410
 7411    def __init__(
 7412        self,
 7413        *,
 7414        pagerItems: Sequence[Dict[str, Any]],
 7415        problems: Sequence[Dict[str, Any]],
 7416        # Ignore any unknown arguments
 7417        **_kwargs: Any,
 7418    ):
 7419        self.pagerItems = [_PageItem(**v) for v in pagerItems]
 7420        self.problems = [_ProblemListItem(**v) for v in problems]
 7421
 7422
 7423@dataclasses.dataclass
 7424class _OmegaUp_Controllers_Problem__apiAdmins:
 7425    """_OmegaUp_Controllers_Problem__apiAdmins"""
 7426    admins: Sequence['_ProblemAdmin']
 7427    group_admins: Sequence['_ProblemGroupAdmin']
 7428
 7429    def __init__(
 7430        self,
 7431        *,
 7432        admins: Sequence[Dict[str, Any]],
 7433        group_admins: Sequence[Dict[str, Any]],
 7434        # Ignore any unknown arguments
 7435        **_kwargs: Any,
 7436    ):
 7437        self.admins = [_ProblemAdmin(**v) for v in admins]
 7438        self.group_admins = [_ProblemGroupAdmin(**v) for v in group_admins]
 7439
 7440
 7441@dataclasses.dataclass
 7442class _OmegaUp_Controllers_Problem__apiBestScore:
 7443    """_OmegaUp_Controllers_Problem__apiBestScore"""
 7444    score: float
 7445
 7446    def __init__(
 7447        self,
 7448        *,
 7449        score: float,
 7450        # Ignore any unknown arguments
 7451        **_kwargs: Any,
 7452    ):
 7453        self.score = score
 7454
 7455
 7456@dataclasses.dataclass
 7457class _OmegaUp_Controllers_Problem__apiClarifications:
 7458    """_OmegaUp_Controllers_Problem__apiClarifications"""
 7459    clarifications: Sequence['_Clarification']
 7460
 7461    def __init__(
 7462        self,
 7463        *,
 7464        clarifications: Sequence[Dict[str, Any]],
 7465        # Ignore any unknown arguments
 7466        **_kwargs: Any,
 7467    ):
 7468        self.clarifications = [_Clarification(**v) for v in clarifications]
 7469
 7470
 7471@dataclasses.dataclass
 7472class _OmegaUp_Controllers_Problem__apiList:
 7473    """_OmegaUp_Controllers_Problem__apiList"""
 7474    results: Sequence['_ProblemListItem']
 7475    total: int
 7476
 7477    def __init__(
 7478        self,
 7479        *,
 7480        results: Sequence[Dict[str, Any]],
 7481        total: int,
 7482        # Ignore any unknown arguments
 7483        **_kwargs: Any,
 7484    ):
 7485        self.results = [_ProblemListItem(**v) for v in results]
 7486        self.total = total
 7487
 7488
 7489@dataclasses.dataclass
 7490class _OmegaUp_Controllers_Problem__apiListForTypeahead:
 7491    """_OmegaUp_Controllers_Problem__apiListForTypeahead"""
 7492    results: Sequence['_ListItem']
 7493
 7494    def __init__(
 7495        self,
 7496        *,
 7497        results: Sequence[Dict[str, Any]],
 7498        # Ignore any unknown arguments
 7499        **_kwargs: Any,
 7500    ):
 7501        self.results = [_ListItem(**v) for v in results]
 7502
 7503
 7504@dataclasses.dataclass
 7505class _OmegaUp_Controllers_Problem__apiMyList:
 7506    """_OmegaUp_Controllers_Problem__apiMyList"""
 7507    pagerItems: Sequence['_PageItem']
 7508    problems: Sequence['_ProblemListItem']
 7509
 7510    def __init__(
 7511        self,
 7512        *,
 7513        pagerItems: Sequence[Dict[str, Any]],
 7514        problems: Sequence[Dict[str, Any]],
 7515        # Ignore any unknown arguments
 7516        **_kwargs: Any,
 7517    ):
 7518        self.pagerItems = [_PageItem(**v) for v in pagerItems]
 7519        self.problems = [_ProblemListItem(**v) for v in problems]
 7520
 7521
 7522@dataclasses.dataclass
 7523class _OmegaUp_Controllers_Problem__apiRandomKarelProblem:
 7524    """_OmegaUp_Controllers_Problem__apiRandomKarelProblem"""
 7525    alias: str
 7526
 7527    def __init__(
 7528        self,
 7529        *,
 7530        alias: str,
 7531        # Ignore any unknown arguments
 7532        **_kwargs: Any,
 7533    ):
 7534        self.alias = alias
 7535
 7536
 7537@dataclasses.dataclass
 7538class _OmegaUp_Controllers_Problem__apiRandomLanguageProblem:
 7539    """_OmegaUp_Controllers_Problem__apiRandomLanguageProblem"""
 7540    alias: str
 7541
 7542    def __init__(
 7543        self,
 7544        *,
 7545        alias: str,
 7546        # Ignore any unknown arguments
 7547        **_kwargs: Any,
 7548    ):
 7549        self.alias = alias
 7550
 7551
 7552@dataclasses.dataclass
 7553class _OmegaUp_Controllers_Problem__apiRuns:
 7554    """_OmegaUp_Controllers_Problem__apiRuns"""
 7555    runs: Sequence['_Run']
 7556    totalRuns: int
 7557
 7558    def __init__(
 7559        self,
 7560        *,
 7561        runs: Sequence[Dict[str, Any]],
 7562        totalRuns: int,
 7563        # Ignore any unknown arguments
 7564        **_kwargs: Any,
 7565    ):
 7566        self.runs = [_Run(**v) for v in runs]
 7567        self.totalRuns = totalRuns
 7568
 7569
 7570@dataclasses.dataclass
 7571class _OmegaUp_Controllers_Problem__apiRunsDiff:
 7572    """_OmegaUp_Controllers_Problem__apiRunsDiff"""
 7573    diff: Sequence['_RunsDiff']
 7574
 7575    def __init__(
 7576        self,
 7577        *,
 7578        diff: Sequence[Dict[str, Any]],
 7579        # Ignore any unknown arguments
 7580        **_kwargs: Any,
 7581    ):
 7582        self.diff = [_RunsDiff(**v) for v in diff]
 7583
 7584
 7585@dataclasses.dataclass
 7586class _OmegaUp_Controllers_Problem__apiSolution:
 7587    """_OmegaUp_Controllers_Problem__apiSolution"""
 7588    solution: Optional['_ProblemStatement']
 7589
 7590    def __init__(
 7591        self,
 7592        *,
 7593        solution: Optional[Dict[str, Any]] = None,
 7594        # Ignore any unknown arguments
 7595        **_kwargs: Any,
 7596    ):
 7597        if solution is not None:
 7598            self.solution = _ProblemStatement(**solution)
 7599        else:
 7600            self.solution = None
 7601
 7602
 7603@dataclasses.dataclass
 7604class _OmegaUp_Controllers_Problem__apiStats:
 7605    """_OmegaUp_Controllers_Problem__apiStats"""
 7606    cases_stats: Dict[str, int]
 7607    pending_runs: Sequence[str]
 7608    total_runs: int
 7609    verdict_counts: Dict[str, int]
 7610
 7611    def __init__(
 7612        self,
 7613        *,
 7614        cases_stats: Dict[str, int],
 7615        pending_runs: Sequence[str],
 7616        total_runs: int,
 7617        verdict_counts: Dict[str, int],
 7618        # Ignore any unknown arguments
 7619        **_kwargs: Any,
 7620    ):
 7621        self.cases_stats = {k: v for k, v in cases_stats.items()}
 7622        self.pending_runs = [v for v in pending_runs]
 7623        self.total_runs = total_runs
 7624        self.verdict_counts = {k: v for k, v in verdict_counts.items()}
 7625
 7626
 7627@dataclasses.dataclass
 7628class _OmegaUp_Controllers_Problem__apiTags:
 7629    """_OmegaUp_Controllers_Problem__apiTags"""
 7630    tags: Sequence['_OmegaUp_Controllers_Problem__apiTags_tags_entry']
 7631
 7632    def __init__(
 7633        self,
 7634        *,
 7635        tags: Sequence[Dict[str, Any]],
 7636        # Ignore any unknown arguments
 7637        **_kwargs: Any,
 7638    ):
 7639        self.tags = [
 7640            _OmegaUp_Controllers_Problem__apiTags_tags_entry(**v) for v in tags
 7641        ]
 7642
 7643
 7644@dataclasses.dataclass
 7645class _OmegaUp_Controllers_Problem__apiTags_tags_entry:
 7646    """_OmegaUp_Controllers_Problem__apiTags_tags_entry"""
 7647    name: str
 7648    public: bool
 7649
 7650    def __init__(
 7651        self,
 7652        *,
 7653        name: str,
 7654        public: bool,
 7655        # Ignore any unknown arguments
 7656        **_kwargs: Any,
 7657    ):
 7658        self.name = name
 7659        self.public = public
 7660
 7661
 7662@dataclasses.dataclass
 7663class _OmegaUp_Controllers_Problem__apiUpdate:
 7664    """_OmegaUp_Controllers_Problem__apiUpdate"""
 7665    rejudged: bool
 7666
 7667    def __init__(
 7668        self,
 7669        *,
 7670        rejudged: bool,
 7671        # Ignore any unknown arguments
 7672        **_kwargs: Any,
 7673    ):
 7674        self.rejudged = rejudged
 7675
 7676
 7677@dataclasses.dataclass
 7678class _OmegaUp_Controllers_Problem__apiVersions:
 7679    """_OmegaUp_Controllers_Problem__apiVersions"""
 7680    log: Sequence['_ProblemVersion']
 7681    published: str
 7682
 7683    def __init__(
 7684        self,
 7685        *,
 7686        log: Sequence[Dict[str, Any]],
 7687        published: str,
 7688        # Ignore any unknown arguments
 7689        **_kwargs: Any,
 7690    ):
 7691        self.log = [_ProblemVersion(**v) for v in log]
 7692        self.published = published
 7693
 7694
 7695@dataclasses.dataclass
 7696class _OmegaUp_Controllers_Problemset__apiScoreboardEvents:
 7697    """_OmegaUp_Controllers_Problemset__apiScoreboardEvents"""
 7698    events: Sequence['_ScoreboardEvent']
 7699
 7700    def __init__(
 7701        self,
 7702        *,
 7703        events: Sequence[Dict[str, Any]],
 7704        # Ignore any unknown arguments
 7705        **_kwargs: Any,
 7706    ):
 7707        self.events = [_ScoreboardEvent(**v) for v in events]
 7708
 7709
 7710@dataclasses.dataclass
 7711class _OmegaUp_Controllers_QualityNomination__apiCreate:
 7712    """_OmegaUp_Controllers_QualityNomination__apiCreate"""
 7713    qualitynomination_id: int
 7714
 7715    def __init__(
 7716        self,
 7717        *,
 7718        qualitynomination_id: int,
 7719        # Ignore any unknown arguments
 7720        **_kwargs: Any,
 7721    ):
 7722        self.qualitynomination_id = qualitynomination_id
 7723
 7724
 7725@dataclasses.dataclass
 7726class _OmegaUp_Controllers_QualityNomination__apiDetails:
 7727    """_OmegaUp_Controllers_QualityNomination__apiDetails"""
 7728    author: '_OmegaUp_Controllers_QualityNomination__apiDetails_author'
 7729    contents: Optional[
 7730        '_OmegaUp_Controllers_QualityNomination__apiDetails_contents']
 7731    nomination: str
 7732    nomination_status: str
 7733    nominator: '_OmegaUp_Controllers_QualityNomination__apiDetails_nominator'
 7734    original_contents: Optional[
 7735        '_OmegaUp_Controllers_QualityNomination__apiDetails_original_contents']
 7736    problem: '_OmegaUp_Controllers_QualityNomination__apiDetails_problem'
 7737    qualitynomination_id: int
 7738    reviewer: bool
 7739    time: datetime.datetime
 7740    votes: Sequence[
 7741        '_OmegaUp_Controllers_QualityNomination__apiDetails_votes_entry']
 7742
 7743    def __init__(
 7744        self,
 7745        *,
 7746        author: Dict[str, Any],
 7747        nomination: str,
 7748        nomination_status: str,
 7749        nominator: Dict[str, Any],
 7750        problem: Dict[str, Any],
 7751        qualitynomination_id: int,
 7752        reviewer: bool,
 7753        time: int,
 7754        votes: Sequence[Dict[str, Any]],
 7755        contents: Optional[Dict[str, Any]] = None,
 7756        original_contents: Optional[Dict[str, Any]] = None,
 7757        # Ignore any unknown arguments
 7758        **_kwargs: Any,
 7759    ):
 7760        self.author = _OmegaUp_Controllers_QualityNomination__apiDetails_author(
 7761            **author)
 7762        if contents is not None:
 7763            self.contents = _OmegaUp_Controllers_QualityNomination__apiDetails_contents(
 7764                **contents)
 7765        else:
 7766            self.contents = None
 7767        self.nomination = nomination
 7768        self.nomination_status = nomination_status
 7769        self.nominator = _OmegaUp_Controllers_QualityNomination__apiDetails_nominator(
 7770            **nominator)
 7771        if original_contents is not None:
 7772            self.original_contents = _OmegaUp_Controllers_QualityNomination__apiDetails_original_contents(
 7773                **original_contents)
 7774        else:
 7775            self.original_contents = None
 7776        self.problem = _OmegaUp_Controllers_QualityNomination__apiDetails_problem(
 7777            **problem)
 7778        self.qualitynomination_id = qualitynomination_id
 7779        self.reviewer = reviewer
 7780        self.time = datetime.datetime.fromtimestamp(time)
 7781        self.votes = [
 7782            _OmegaUp_Controllers_QualityNomination__apiDetails_votes_entry(**v)
 7783            for v in votes
 7784        ]
 7785
 7786
 7787@dataclasses.dataclass
 7788class _OmegaUp_Controllers_QualityNomination__apiDetails_author:
 7789    """_OmegaUp_Controllers_QualityNomination__apiDetails_author"""
 7790    name: str
 7791    username: str
 7792
 7793    def __init__(
 7794        self,
 7795        *,
 7796        name: str,
 7797        username: str,
 7798        # Ignore any unknown arguments
 7799        **_kwargs: Any,
 7800    ):
 7801        self.name = name
 7802        self.username = username
 7803
 7804
 7805@dataclasses.dataclass
 7806class _OmegaUp_Controllers_QualityNomination__apiDetails_contents:
 7807    """_OmegaUp_Controllers_QualityNomination__apiDetails_contents"""
 7808    before_ac: Optional[bool]
 7809    difficulty: Optional[int]
 7810    quality: Optional[int]
 7811    rationale: Optional[str]
 7812    reason: Optional[str]
 7813    statements: Optional[Dict[str, str]]
 7814    tags: Optional[Sequence[str]]
 7815
 7816    def __init__(
 7817        self,
 7818        *,
 7819        before_ac: Optional[bool] = None,
 7820        difficulty: Optional[int] = None,
 7821        quality: Optional[int] = None,
 7822        rationale: Optional[str] = None,
 7823        reason: Optional[str] = None,
 7824        statements: Optional[Dict[str, str]] = None,
 7825        tags: Optional[Sequence[str]] = None,
 7826        # Ignore any unknown arguments
 7827        **_kwargs: Any,
 7828    ):
 7829        if before_ac is not None:
 7830            self.before_ac = before_ac
 7831        else:
 7832            self.before_ac = None
 7833        if difficulty is not None:
 7834            self.difficulty = difficulty
 7835        else:
 7836            self.difficulty = None
 7837        if quality is not None:
 7838            self.quality = quality
 7839        else:
 7840            self.quality = None
 7841        if rationale is not None:
 7842            self.rationale = rationale
 7843        else:
 7844            self.rationale = None
 7845        if reason is not None:
 7846            self.reason = reason
 7847        else:
 7848            self.reason = None
 7849        if statements is not None:
 7850            self.statements = {k: v for k, v in statements.items()}
 7851        else:
 7852            self.statements = None
 7853        if tags is not None:
 7854            self.tags = [v for v in tags]
 7855        else:
 7856            self.tags = None
 7857
 7858
 7859@dataclasses.dataclass
 7860class _OmegaUp_Controllers_QualityNomination__apiDetails_nominator:
 7861    """_OmegaUp_Controllers_QualityNomination__apiDetails_nominator"""
 7862    name: str
 7863    username: str
 7864
 7865    def __init__(
 7866        self,
 7867        *,
 7868        name: str,
 7869        username: str,
 7870        # Ignore any unknown arguments
 7871        **_kwargs: Any,
 7872    ):
 7873        self.name = name
 7874        self.username = username
 7875
 7876
 7877@dataclasses.dataclass
 7878class _OmegaUp_Controllers_QualityNomination__apiDetails_original_contents:
 7879    """_OmegaUp_Controllers_QualityNomination__apiDetails_original_contents"""
 7880    source: str
 7881    statements: Dict[str, '_ProblemStatement']
 7882    tags: Optional[Sequence[
 7883        '_OmegaUp_Controllers_QualityNomination__apiDetails_original_contents_tags_entry']]
 7884
 7885    def __init__(
 7886        self,
 7887        *,
 7888        source: str,
 7889        statements: Dict[str, Dict[str, Any]],
 7890        tags: Optional[Sequence[Dict[str, Any]]] = None,
 7891        # Ignore any unknown arguments
 7892        **_kwargs: Any,
 7893    ):
 7894        self.source = source
 7895        self.statements = {
 7896            k: _ProblemStatement(**v)
 7897            for k, v in statements.items()
 7898        }
 7899        if tags is not None:
 7900            self.tags = [
 7901                _OmegaUp_Controllers_QualityNomination__apiDetails_original_contents_tags_entry(
 7902                    **v) for v in tags
 7903            ]
 7904        else:
 7905            self.tags = None
 7906
 7907
 7908@dataclasses.dataclass
 7909class _OmegaUp_Controllers_QualityNomination__apiDetails_original_contents_tags_entry:
 7910    """_OmegaUp_Controllers_QualityNomination__apiDetails_original_contents_tags_entry"""
 7911    name: str
 7912    source: str
 7913
 7914    def __init__(
 7915        self,
 7916        *,
 7917        name: str,
 7918        source: str,
 7919        # Ignore any unknown arguments
 7920        **_kwargs: Any,
 7921    ):
 7922        self.name = name
 7923        self.source = source
 7924
 7925
 7926@dataclasses.dataclass
 7927class _OmegaUp_Controllers_QualityNomination__apiDetails_problem:
 7928    """_OmegaUp_Controllers_QualityNomination__apiDetails_problem"""
 7929    alias: str
 7930    title: str
 7931
 7932    def __init__(
 7933        self,
 7934        *,
 7935        alias: str,
 7936        title: str,
 7937        # Ignore any unknown arguments
 7938        **_kwargs: Any,
 7939    ):
 7940        self.alias = alias
 7941        self.title = title
 7942
 7943
 7944@dataclasses.dataclass
 7945class _OmegaUp_Controllers_QualityNomination__apiDetails_votes_entry:
 7946    """_OmegaUp_Controllers_QualityNomination__apiDetails_votes_entry"""
 7947    time: datetime.datetime
 7948    user: '_OmegaUp_Controllers_QualityNomination__apiDetails_votes_entry_user'
 7949    vote: int
 7950
 7951    def __init__(
 7952        self,
 7953        *,
 7954        time: int,
 7955        user: Dict[str, Any],
 7956        vote: int,
 7957        # Ignore any unknown arguments
 7958        **_kwargs: Any,
 7959    ):
 7960        self.time = datetime.datetime.fromtimestamp(time)
 7961        self.user = _OmegaUp_Controllers_QualityNomination__apiDetails_votes_entry_user(
 7962            **user)
 7963        self.vote = vote
 7964
 7965
 7966@dataclasses.dataclass
 7967class _OmegaUp_Controllers_QualityNomination__apiDetails_votes_entry_user:
 7968    """_OmegaUp_Controllers_QualityNomination__apiDetails_votes_entry_user"""
 7969    name: str
 7970    username: str
 7971
 7972    def __init__(
 7973        self,
 7974        *,
 7975        name: str,
 7976        username: str,
 7977        # Ignore any unknown arguments
 7978        **_kwargs: Any,
 7979    ):
 7980        self.name = name
 7981        self.username = username
 7982
 7983
 7984@dataclasses.dataclass
 7985class _OmegaUp_Controllers_QualityNomination__apiList:
 7986    """_OmegaUp_Controllers_QualityNomination__apiList"""
 7987    nominations: Sequence['_NominationListItem']
 7988    pager_items: Sequence['_PageItem']
 7989
 7990    def __init__(
 7991        self,
 7992        *,
 7993        nominations: Sequence[Dict[str, Any]],
 7994        pager_items: Sequence[Dict[str, Any]],
 7995        # Ignore any unknown arguments
 7996        **_kwargs: Any,
 7997    ):
 7998        self.nominations = [_NominationListItem(**v) for v in nominations]
 7999        self.pager_items = [_PageItem(**v) for v in pager_items]
 8000
 8001
 8002@dataclasses.dataclass
 8003class _OmegaUp_Controllers_QualityNomination__apiMyAssignedList:
 8004    """_OmegaUp_Controllers_QualityNomination__apiMyAssignedList"""
 8005    nominations: Sequence[
 8006        '_OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry']
 8007
 8008    def __init__(
 8009        self,
 8010        *,
 8011        nominations: Sequence[Dict[str, Any]],
 8012        # Ignore any unknown arguments
 8013        **_kwargs: Any,
 8014    ):
 8015        self.nominations = [
 8016            _OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry(
 8017                **v) for v in nominations
 8018        ]
 8019
 8020
 8021@dataclasses.dataclass
 8022class _OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry:
 8023    """_OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry"""
 8024    author: '_OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry_author'
 8025    contents: Optional[
 8026        '_OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry_contents']
 8027    nomination: str
 8028    nominator: '_OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry_nominator'
 8029    problem: '_OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry_problem'
 8030    qualitynomination_id: int
 8031    status: str
 8032    time: datetime.datetime
 8033    votes: Sequence[
 8034        '_OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry_votes_entry']
 8035
 8036    def __init__(
 8037        self,
 8038        *,
 8039        author: Dict[str, Any],
 8040        nomination: str,
 8041        nominator: Dict[str, Any],
 8042        problem: Dict[str, Any],
 8043        qualitynomination_id: int,
 8044        status: str,
 8045        time: int,
 8046        votes: Sequence[Dict[str, Any]],
 8047        contents: Optional[Dict[str, Any]] = None,
 8048        # Ignore any unknown arguments
 8049        **_kwargs: Any,
 8050    ):
 8051        self.author = _OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry_author(
 8052            **author)
 8053        if contents is not None:
 8054            self.contents = _OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry_contents(
 8055                **contents)
 8056        else:
 8057            self.contents = None
 8058        self.nomination = nomination
 8059        self.nominator = _OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry_nominator(
 8060            **nominator)
 8061        self.problem = _OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry_problem(
 8062            **problem)
 8063        self.qualitynomination_id = qualitynomination_id
 8064        self.status = status
 8065        self.time = datetime.datetime.fromtimestamp(time)
 8066        self.votes = [
 8067            _OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry_votes_entry(
 8068                **v) for v in votes
 8069        ]
 8070
 8071
 8072@dataclasses.dataclass
 8073class _OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry_author:
 8074    """_OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry_author"""
 8075    name: str
 8076    username: str
 8077
 8078    def __init__(
 8079        self,
 8080        *,
 8081        name: str,
 8082        username: str,
 8083        # Ignore any unknown arguments
 8084        **_kwargs: Any,
 8085    ):
 8086        self.name = name
 8087        self.username = username
 8088
 8089
 8090@dataclasses.dataclass
 8091class _OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry_contents:
 8092    """_OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry_contents"""
 8093    before_ac: Optional[bool]
 8094    difficulty: Optional[int]
 8095    quality: Optional[int]
 8096    rationale: Optional[str]
 8097    reason: Optional[str]
 8098    statements: Optional[Dict[str, str]]
 8099    tags: Optional[Sequence[str]]
 8100
 8101    def __init__(
 8102        self,
 8103        *,
 8104        before_ac: Optional[bool] = None,
 8105        difficulty: Optional[int] = None,
 8106        quality: Optional[int] = None,
 8107        rationale: Optional[str] = None,
 8108        reason: Optional[str] = None,
 8109        statements: Optional[Dict[str, str]] = None,
 8110        tags: Optional[Sequence[str]] = None,
 8111        # Ignore any unknown arguments
 8112        **_kwargs: Any,
 8113    ):
 8114        if before_ac is not None:
 8115            self.before_ac = before_ac
 8116        else:
 8117            self.before_ac = None
 8118        if difficulty is not None:
 8119            self.difficulty = difficulty
 8120        else:
 8121            self.difficulty = None
 8122        if quality is not None:
 8123            self.quality = quality
 8124        else:
 8125            self.quality = None
 8126        if rationale is not None:
 8127            self.rationale = rationale
 8128        else:
 8129            self.rationale = None
 8130        if reason is not None:
 8131            self.reason = reason
 8132        else:
 8133            self.reason = None
 8134        if statements is not None:
 8135            self.statements = {k: v for k, v in statements.items()}
 8136        else:
 8137            self.statements = None
 8138        if tags is not None:
 8139            self.tags = [v for v in tags]
 8140        else:
 8141            self.tags = None
 8142
 8143
 8144@dataclasses.dataclass
 8145class _OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry_nominator:
 8146    """_OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry_nominator"""
 8147    name: str
 8148    username: str
 8149
 8150    def __init__(
 8151        self,
 8152        *,
 8153        name: str,
 8154        username: str,
 8155        # Ignore any unknown arguments
 8156        **_kwargs: Any,
 8157    ):
 8158        self.name = name
 8159        self.username = username
 8160
 8161
 8162@dataclasses.dataclass
 8163class _OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry_problem:
 8164    """_OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry_problem"""
 8165    alias: str
 8166    title: str
 8167
 8168    def __init__(
 8169        self,
 8170        *,
 8171        alias: str,
 8172        title: str,
 8173        # Ignore any unknown arguments
 8174        **_kwargs: Any,
 8175    ):
 8176        self.alias = alias
 8177        self.title = title
 8178
 8179
 8180@dataclasses.dataclass
 8181class _OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry_votes_entry:
 8182    """_OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry_votes_entry"""
 8183    time: datetime.datetime
 8184    user: '_OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry_votes_entry_user'
 8185    vote: int
 8186
 8187    def __init__(
 8188        self,
 8189        *,
 8190        time: int,
 8191        user: Dict[str, Any],
 8192        vote: int,
 8193        # Ignore any unknown arguments
 8194        **_kwargs: Any,
 8195    ):
 8196        self.time = datetime.datetime.fromtimestamp(time)
 8197        self.user = _OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry_votes_entry_user(
 8198            **user)
 8199        self.vote = vote
 8200
 8201
 8202@dataclasses.dataclass
 8203class _OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry_votes_entry_user:
 8204    """_OmegaUp_Controllers_QualityNomination__apiMyAssignedList_nominations_entry_votes_entry_user"""
 8205    name: str
 8206    username: str
 8207
 8208    def __init__(
 8209        self,
 8210        *,
 8211        name: str,
 8212        username: str,
 8213        # Ignore any unknown arguments
 8214        **_kwargs: Any,
 8215    ):
 8216        self.name = name
 8217        self.username = username
 8218
 8219
 8220@dataclasses.dataclass
 8221class _OmegaUp_Controllers_QualityNomination__apiMyList:
 8222    """_OmegaUp_Controllers_QualityNomination__apiMyList"""
 8223    nominations: Sequence['_NominationListItem']
 8224    pager_items: Sequence['_PageItem']
 8225
 8226    def __init__(
 8227        self,
 8228        *,
 8229        nominations: Sequence[Dict[str, Any]],
 8230        pager_items: Sequence[Dict[str, Any]],
 8231        # Ignore any unknown arguments
 8232        **_kwargs: Any,
 8233    ):
 8234        self.nominations = [_NominationListItem(**v) for v in nominations]
 8235        self.pager_items = [_PageItem(**v) for v in pager_items]
 8236
 8237
 8238@dataclasses.dataclass
 8239class _OmegaUp_Controllers_Reset__apiCreate:
 8240    """_OmegaUp_Controllers_Reset__apiCreate"""
 8241    message: Optional[str]
 8242    token: Optional[str]
 8243
 8244    def __init__(
 8245        self,
 8246        *,
 8247        message: Optional[str] = None,
 8248        token: Optional[str] = None,
 8249        # Ignore any unknown arguments
 8250        **_kwargs: Any,
 8251    ):
 8252        if message is not None:
 8253            self.message = message
 8254        else:
 8255            self.message = None
 8256        if token is not None:
 8257            self.token = token
 8258        else:
 8259            self.token = None
 8260
 8261
 8262@dataclasses.dataclass
 8263class _OmegaUp_Controllers_Reset__apiGenerateToken:
 8264    """_OmegaUp_Controllers_Reset__apiGenerateToken"""
 8265    link: str
 8266    token: str
 8267
 8268    def __init__(
 8269        self,
 8270        *,
 8271        link: str,
 8272        token: str,
 8273        # Ignore any unknown arguments
 8274        **_kwargs: Any,
 8275    ):
 8276        self.link = link
 8277        self.token = token
 8278
 8279
 8280@dataclasses.dataclass
 8281class _OmegaUp_Controllers_Reset__apiUpdate:
 8282    """_OmegaUp_Controllers_Reset__apiUpdate"""
 8283    message: str
 8284
 8285    def __init__(
 8286        self,
 8287        *,
 8288        message: str,
 8289        # Ignore any unknown arguments
 8290        **_kwargs: Any,
 8291    ):
 8292        self.message = message
 8293
 8294
 8295@dataclasses.dataclass
 8296class _OmegaUp_Controllers_Run__apiCounts:
 8297    """_OmegaUp_Controllers_Run__apiCounts"""
 8298    ac: Dict[str, int]
 8299    total: Dict[str, int]
 8300
 8301    def __init__(
 8302        self,
 8303        *,
 8304        ac: Dict[str, int],
 8305        total: Dict[str, int],
 8306        # Ignore any unknown arguments
 8307        **_kwargs: Any,
 8308    ):
 8309        self.ac = {k: v for k, v in ac.items()}
 8310        self.total = {k: v for k, v in total.items()}
 8311
 8312
 8313@dataclasses.dataclass
 8314class _OmegaUp_Controllers_Run__apiCreate:
 8315    """_OmegaUp_Controllers_Run__apiCreate"""
 8316    guid: str
 8317    nextSubmissionTimestamp: datetime.datetime
 8318    submission_deadline: datetime.datetime
 8319    submit_delay: int
 8320
 8321    def __init__(
 8322        self,
 8323        *,
 8324        guid: str,
 8325        nextSubmissionTimestamp: int,
 8326        submission_deadline: int,
 8327        submit_delay: int,
 8328        # Ignore any unknown arguments
 8329        **_kwargs: Any,
 8330    ):
 8331        self.guid = guid
 8332        self.nextSubmissionTimestamp = datetime.datetime.fromtimestamp(
 8333            nextSubmissionTimestamp)
 8334        self.submission_deadline = datetime.datetime.fromtimestamp(
 8335            submission_deadline)
 8336        self.submit_delay = submit_delay
 8337
 8338
 8339@dataclasses.dataclass
 8340class _OmegaUp_Controllers_Run__apiList:
 8341    """_OmegaUp_Controllers_Run__apiList"""
 8342    runs: Sequence['_Run']
 8343    totalRuns: int
 8344
 8345    def __init__(
 8346        self,
 8347        *,
 8348        runs: Sequence[Dict[str, Any]],
 8349        totalRuns: int,
 8350        # Ignore any unknown arguments
 8351        **_kwargs: Any,
 8352    ):
 8353        self.runs = [_Run(**v) for v in runs]
 8354        self.totalRuns = totalRuns
 8355
 8356
 8357@dataclasses.dataclass
 8358class _OmegaUp_Controllers_Run__apiSource:
 8359    """_OmegaUp_Controllers_Run__apiSource"""
 8360    compile_error: Optional[str]
 8361    details: Optional['_OmegaUp_Controllers_Run__apiSource_details']
 8362    source: str
 8363
 8364    def __init__(
 8365        self,
 8366        *,
 8367        source: str,
 8368        compile_error: Optional[str] = None,
 8369        details: Optional[Dict[str, Any]] = None,
 8370        # Ignore any unknown arguments
 8371        **_kwargs: Any,
 8372    ):
 8373        if compile_error is not None:
 8374            self.compile_error = compile_error
 8375        else:
 8376            self.compile_error = None
 8377        if details is not None:
 8378            self.details = _OmegaUp_Controllers_Run__apiSource_details(
 8379                **details)
 8380        else:
 8381            self.details = None
 8382        self.source = source
 8383
 8384
 8385@dataclasses.dataclass
 8386class _OmegaUp_Controllers_Run__apiSource_details:
 8387    """_OmegaUp_Controllers_Run__apiSource_details"""
 8388    compile_meta: Optional[Dict[str, '_RunMetadata']]
 8389    contest_score: float
 8390    groups: Optional[
 8391        Sequence['_OmegaUp_Controllers_Run__apiSource_details_groups_entry']]
 8392    judged_by: str
 8393    max_score: Optional[float]
 8394    memory: Optional[float]
 8395    score: float
 8396    time: Optional[float]
 8397    verdict: str
 8398    wall_time: Optional[float]
 8399
 8400    def __init__(
 8401        self,
 8402        *,
 8403        contest_score: float,
 8404        judged_by: str,
 8405        score: float,
 8406        verdict: str,
 8407        compile_meta: Optional[Dict[str, Dict[str, Any]]] = None,
 8408        groups: Optional[Sequence[Dict[str, Any]]] = None,
 8409        max_score: Optional[float] = None,
 8410        memory: Optional[float] = None,
 8411        time: Optional[float] = None,
 8412        wall_time: Optional[float] = None,
 8413        # Ignore any unknown arguments
 8414        **_kwargs: Any,
 8415    ):
 8416        if compile_meta is not None:
 8417            self.compile_meta = {
 8418                k: _RunMetadata(**v)
 8419                for k, v in compile_meta.items()
 8420            }
 8421        else:
 8422            self.compile_meta = None
 8423        self.contest_score = contest_score
 8424        if groups is not None:
 8425            self.groups = [
 8426                _OmegaUp_Controllers_Run__apiSource_details_groups_entry(**v)
 8427                for v in groups
 8428            ]
 8429        else:
 8430            self.groups = None
 8431        self.judged_by = judged_by
 8432        if max_score is not None:
 8433            self.max_score = max_score
 8434        else:
 8435            self.max_score = None
 8436        if memory is not None:
 8437            self.memory = memory
 8438        else:
 8439            self.memory = None
 8440        self.score = score
 8441        if time is not None:
 8442            self.time = time
 8443        else:
 8444            self.time = None
 8445        self.verdict = verdict
 8446        if wall_time is not None:
 8447            self.wall_time = wall_time
 8448        else:
 8449            self.wall_time = None
 8450
 8451
 8452@dataclasses.dataclass
 8453class _OmegaUp_Controllers_Run__apiSource_details_groups_entry:
 8454    """_OmegaUp_Controllers_Run__apiSource_details_groups_entry"""
 8455    cases: Sequence['_CaseResult']
 8456    contest_score: float
 8457    group: str
 8458    max_score: float
 8459    score: float
 8460
 8461    def __init__(
 8462        self,
 8463        *,
 8464        cases: Sequence[Dict[str, Any]],
 8465        contest_score: float,
 8466        group: str,
 8467        max_score: float,
 8468        score: float,
 8469        # Ignore any unknown arguments
 8470        **_kwargs: Any,
 8471    ):
 8472        self.cases = [_CaseResult(**v) for v in cases]
 8473        self.contest_score = contest_score
 8474        self.group = group
 8475        self.max_score = max_score
 8476        self.score = score
 8477
 8478
 8479@dataclasses.dataclass
 8480class _OmegaUp_Controllers_School__apiCreate:
 8481    """_OmegaUp_Controllers_School__apiCreate"""
 8482    school_id: int
 8483
 8484    def __init__(
 8485        self,
 8486        *,
 8487        school_id: int,
 8488        # Ignore any unknown arguments
 8489        **_kwargs: Any,
 8490    ):
 8491        self.school_id = school_id
 8492
 8493
 8494@dataclasses.dataclass
 8495class _OmegaUp_Controllers_School__apiList:
 8496    """_OmegaUp_Controllers_School__apiList"""
 8497    results: Sequence['_SchoolListItem']
 8498
 8499    def __init__(
 8500        self,
 8501        *,
 8502        results: Sequence[Dict[str, Any]],
 8503        # Ignore any unknown arguments
 8504        **_kwargs: Any,
 8505    ):
 8506        self.results = [_SchoolListItem(**v) for v in results]
 8507
 8508
 8509@dataclasses.dataclass
 8510class _OmegaUp_Controllers_Session__apiCurrentSession:
 8511    """_OmegaUp_Controllers_Session__apiCurrentSession"""
 8512    session: Optional['_CurrentSession']
 8513    time: int
 8514
 8515    def __init__(
 8516        self,
 8517        *,
 8518        time: int,
 8519        session: Optional[Dict[str, Any]] = None,
 8520        # Ignore any unknown arguments
 8521        **_kwargs: Any,
 8522    ):
 8523        if session is not None:
 8524            self.session = _CurrentSession(**session)
 8525        else:
 8526            self.session = None
 8527        self.time = time
 8528
 8529
 8530@dataclasses.dataclass
 8531class _OmegaUp_Controllers_Session__apiGoogleLogin:
 8532    """_OmegaUp_Controllers_Session__apiGoogleLogin"""
 8533    isAccountCreation: bool
 8534
 8535    def __init__(
 8536        self,
 8537        *,
 8538        isAccountCreation: bool,
 8539        # Ignore any unknown arguments
 8540        **_kwargs: Any,
 8541    ):
 8542        self.isAccountCreation = isAccountCreation
 8543
 8544
 8545@dataclasses.dataclass
 8546class _OmegaUp_Controllers_Tag__apiFrequentTags:
 8547    """_OmegaUp_Controllers_Tag__apiFrequentTags"""
 8548    frequent_tags: Sequence['_TagWithProblemCount']
 8549
 8550    def __init__(
 8551        self,
 8552        *,
 8553        frequent_tags: Sequence[Dict[str, Any]],
 8554        # Ignore any unknown arguments
 8555        **_kwargs: Any,
 8556    ):
 8557        self.frequent_tags = [_TagWithProblemCount(**v) for v in frequent_tags]
 8558
 8559
 8560@dataclasses.dataclass
 8561class _OmegaUp_Controllers_Tag__apiList_entry:
 8562    """_OmegaUp_Controllers_Tag__apiList_entry"""
 8563    name: str
 8564
 8565    def __init__(
 8566        self,
 8567        *,
 8568        name: str,
 8569        # Ignore any unknown arguments
 8570        **_kwargs: Any,
 8571    ):
 8572        self.name = name
 8573
 8574
 8575@dataclasses.dataclass
 8576class _OmegaUp_Controllers_TeamsGroup__apiDetails:
 8577    """_OmegaUp_Controllers_TeamsGroup__apiDetails"""
 8578    team_group: '_OmegaUp_Controllers_TeamsGroup__apiDetails_team_group'
 8579
 8580    def __init__(
 8581        self,
 8582        *,
 8583        team_group: Dict[str, Any],
 8584        # Ignore any unknown arguments
 8585        **_kwargs: Any,
 8586    ):
 8587        self.team_group = _OmegaUp_Controllers_TeamsGroup__apiDetails_team_group(
 8588            **team_group)
 8589
 8590
 8591@dataclasses.dataclass
 8592class _OmegaUp_Controllers_TeamsGroup__apiDetails_team_group:
 8593    """_OmegaUp_Controllers_TeamsGroup__apiDetails_team_group"""
 8594    alias: str
 8595    create_time: int
 8596    description: str
 8597    name: str
 8598
 8599    def __init__(
 8600        self,
 8601        *,
 8602        alias: str,
 8603        create_time: int,
 8604        description: str,
 8605        name: str,
 8606        # Ignore any unknown arguments
 8607        **_kwargs: Any,
 8608    ):
 8609        self.alias = alias
 8610        self.create_time = create_time
 8611        self.description = description
 8612        self.name = name
 8613
 8614
 8615@dataclasses.dataclass
 8616class _OmegaUp_Controllers_TeamsGroup__apiTeams:
 8617    """_OmegaUp_Controllers_TeamsGroup__apiTeams"""
 8618    identities: Sequence['_Identity']
 8619
 8620    def __init__(
 8621        self,
 8622        *,
 8623        identities: Sequence[Dict[str, Any]],
 8624        # Ignore any unknown arguments
 8625        **_kwargs: Any,
 8626    ):
 8627        self.identities = [_Identity(**v) for v in identities]
 8628
 8629
 8630@dataclasses.dataclass
 8631class _OmegaUp_Controllers_TeamsGroup__apiTeamsMembers:
 8632    """_OmegaUp_Controllers_TeamsGroup__apiTeamsMembers"""
 8633    pageNumber: int
 8634    teamsUsers: Sequence['_TeamMember']
 8635    totalRows: int
 8636
 8637    def __init__(
 8638        self,
 8639        *,
 8640        pageNumber: int,
 8641        teamsUsers: Sequence[Dict[str, Any]],
 8642        totalRows: int,
 8643        # Ignore any unknown arguments
 8644        **_kwargs: Any,
 8645    ):
 8646        self.pageNumber = pageNumber
 8647        self.teamsUsers = [_TeamMember(**v) for v in teamsUsers]
 8648        self.totalRows = totalRows
 8649
 8650
 8651@dataclasses.dataclass
 8652class _OmegaUp_Controllers_Time__apiGet:
 8653    """_OmegaUp_Controllers_Time__apiGet"""
 8654    time: int
 8655
 8656    def __init__(
 8657        self,
 8658        *,
 8659        time: int,
 8660        # Ignore any unknown arguments
 8661        **_kwargs: Any,
 8662    ):
 8663        self.time = time
 8664
 8665
 8666@dataclasses.dataclass
 8667class _OmegaUp_Controllers_User__apiCoderOfTheMonth:
 8668    """_OmegaUp_Controllers_User__apiCoderOfTheMonth"""
 8669    coderinfo: Optional['_UserProfile']
 8670
 8671    def __init__(
 8672        self,
 8673        *,
 8674        coderinfo: Optional[Dict[str, Any]] = None,
 8675        # Ignore any unknown arguments
 8676        **_kwargs: Any,
 8677    ):
 8678        if coderinfo is not None:
 8679            self.coderinfo = _UserProfile(**coderinfo)
 8680        else:
 8681            self.coderinfo = None
 8682
 8683
 8684@dataclasses.dataclass
 8685class _OmegaUp_Controllers_User__apiCoderOfTheMonthList:
 8686    """_OmegaUp_Controllers_User__apiCoderOfTheMonthList"""
 8687    coders: Sequence['_CoderOfTheMonthList_entry']
 8688
 8689    def __init__(
 8690        self,
 8691        *,
 8692        coders: Sequence[Dict[str, Any]],
 8693        # Ignore any unknown arguments
 8694        **_kwargs: Any,
 8695    ):
 8696        self.coders = [_CoderOfTheMonthList_entry(**v) for v in coders]
 8697
 8698
 8699@dataclasses.dataclass
 8700class _OmegaUp_Controllers_User__apiContestStats:
 8701    """_OmegaUp_Controllers_User__apiContestStats"""
 8702    contests: Dict[str, '_UserProfileContests_value']
 8703
 8704    def __init__(
 8705        self,
 8706        *,
 8707        contests: Dict[str, Dict[str, Any]],
 8708        # Ignore any unknown arguments
 8709        **_kwargs: Any,
 8710    ):
 8711        self.contests = {
 8712            k: _UserProfileContests_value(**v)
 8713            for k, v in contests.items()
 8714        }
 8715
 8716
 8717@dataclasses.dataclass
 8718class _OmegaUp_Controllers_User__apiCreate:
 8719    """_OmegaUp_Controllers_User__apiCreate"""
 8720    username: str
 8721
 8722    def __init__(
 8723        self,
 8724        *,
 8725        username: str,
 8726        # Ignore any unknown arguments
 8727        **_kwargs: Any,
 8728    ):
 8729        self.username = username
 8730
 8731
 8732@dataclasses.dataclass
 8733class _OmegaUp_Controllers_User__apiCreateAPIToken:
 8734    """_OmegaUp_Controllers_User__apiCreateAPIToken"""
 8735    token: str
 8736
 8737    def __init__(
 8738        self,
 8739        *,
 8740        token: str,
 8741        # Ignore any unknown arguments
 8742        **_kwargs: Any,
 8743    ):
 8744        self.token = token
 8745
 8746
 8747@dataclasses.dataclass
 8748class _OmegaUp_Controllers_User__apiDeleteRequest:
 8749    """_OmegaUp_Controllers_User__apiDeleteRequest"""
 8750    token: str
 8751
 8752    def __init__(
 8753        self,
 8754        *,
 8755        token: str,
 8756        # Ignore any unknown arguments
 8757        **_kwargs: Any,
 8758    ):
 8759        self.token = token
 8760
 8761
 8762@dataclasses.dataclass
 8763class _OmegaUp_Controllers_User__apiExtraInformation:
 8764    """_OmegaUp_Controllers_User__apiExtraInformation"""
 8765    birth_date: Optional[datetime.datetime]
 8766    last_login: Optional[datetime.datetime]
 8767    username: str
 8768    verified: bool
 8769    within_last_day: bool
 8770
 8771    def __init__(
 8772        self,
 8773        *,
 8774        username: str,
 8775        verified: bool,
 8776        within_last_day: bool,
 8777        birth_date: Optional[int] = None,
 8778        last_login: Optional[int] = None,
 8779        # Ignore any unknown arguments
 8780        **_kwargs: Any,
 8781    ):
 8782        if birth_date is not None:
 8783            self.birth_date = datetime.datetime.fromtimestamp(birth_date)
 8784        else:
 8785            self.birth_date = None
 8786        if last_login is not None:
 8787            self.last_login = datetime.datetime.fromtimestamp(last_login)
 8788        else:
 8789            self.last_login = None
 8790        self.username = username
 8791        self.verified = verified
 8792        self.within_last_day = within_last_day
 8793
 8794
 8795@dataclasses.dataclass
 8796class _OmegaUp_Controllers_User__apiGenerateGitToken:
 8797    """_OmegaUp_Controllers_User__apiGenerateGitToken"""
 8798    token: str
 8799
 8800    def __init__(
 8801        self,
 8802        *,
 8803        token: str,
 8804        # Ignore any unknown arguments
 8805        **_kwargs: Any,
 8806    ):
 8807        self.token = token
 8808
 8809
 8810@dataclasses.dataclass
 8811class _OmegaUp_Controllers_User__apiLastPrivacyPolicyAccepted:
 8812    """_OmegaUp_Controllers_User__apiLastPrivacyPolicyAccepted"""
 8813    hasAccepted: bool
 8814
 8815    def __init__(
 8816        self,
 8817        *,
 8818        hasAccepted: bool,
 8819        # Ignore any unknown arguments
 8820        **_kwargs: Any,
 8821    ):
 8822        self.hasAccepted = hasAccepted
 8823
 8824
 8825@dataclasses.dataclass
 8826class _OmegaUp_Controllers_User__apiList:
 8827    """_OmegaUp_Controllers_User__apiList"""
 8828    results: Sequence['_ListItem']
 8829
 8830    def __init__(
 8831        self,
 8832        *,
 8833        results: Sequence[Dict[str, Any]],
 8834        # Ignore any unknown arguments
 8835        **_kwargs: Any,
 8836    ):
 8837        self.results = [_ListItem(**v) for v in results]
 8838
 8839
 8840@dataclasses.dataclass
 8841class _OmegaUp_Controllers_User__apiListAPITokens:
 8842    """_OmegaUp_Controllers_User__apiListAPITokens"""
 8843    tokens: Sequence[
 8844        '_OmegaUp_Controllers_User__apiListAPITokens_tokens_entry']
 8845
 8846    def __init__(
 8847        self,
 8848        *,
 8849        tokens: Sequence[Dict[str, Any]],
 8850        # Ignore any unknown arguments
 8851        **_kwargs: Any,
 8852    ):
 8853        self.tokens = [
 8854            _OmegaUp_Controllers_User__apiListAPITokens_tokens_entry(**v)
 8855            for v in tokens
 8856        ]
 8857
 8858
 8859@dataclasses.dataclass
 8860class _OmegaUp_Controllers_User__apiListAPITokens_tokens_entry:
 8861    """_OmegaUp_Controllers_User__apiListAPITokens_tokens_entry"""
 8862    last_used: datetime.datetime
 8863    name: str
 8864    rate_limit: '_OmegaUp_Controllers_User__apiListAPITokens_tokens_entry_rate_limit'
 8865    timestamp: datetime.datetime
 8866
 8867    def __init__(
 8868        self,
 8869        *,
 8870        last_used: int,
 8871        name: str,
 8872        rate_limit: Dict[str, Any],
 8873        timestamp: int,
 8874        # Ignore any unknown arguments
 8875        **_kwargs: Any,
 8876    ):
 8877        self.last_used = datetime.datetime.fromtimestamp(last_used)
 8878        self.name = name
 8879        self.rate_limit = _OmegaUp_Controllers_User__apiListAPITokens_tokens_entry_rate_limit(
 8880            **rate_limit)
 8881        self.timestamp = datetime.datetime.fromtimestamp(timestamp)
 8882
 8883
 8884@dataclasses.dataclass
 8885class _OmegaUp_Controllers_User__apiListAPITokens_tokens_entry_rate_limit:
 8886    """_OmegaUp_Controllers_User__apiListAPITokens_tokens_entry_rate_limit"""
 8887    limit: int
 8888    remaining: int
 8889    reset: datetime.datetime
 8890
 8891    def __init__(
 8892        self,
 8893        *,
 8894        limit: int,
 8895        remaining: int,
 8896        reset: int,
 8897        # Ignore any unknown arguments
 8898        **_kwargs: Any,
 8899    ):
 8900        self.limit = limit
 8901        self.remaining = remaining
 8902        self.reset = datetime.datetime.fromtimestamp(reset)
 8903
 8904
 8905@dataclasses.dataclass
 8906class _OmegaUp_Controllers_User__apiListAssociatedIdentities:
 8907    """_OmegaUp_Controllers_User__apiListAssociatedIdentities"""
 8908    identities: Sequence['_AssociatedIdentity']
 8909
 8910    def __init__(
 8911        self,
 8912        *,
 8913        identities: Sequence[Dict[str, Any]],
 8914        # Ignore any unknown arguments
 8915        **_kwargs: Any,
 8916    ):
 8917        self.identities = [_AssociatedIdentity(**v) for v in identities]
 8918
 8919
 8920@dataclasses.dataclass
 8921class _OmegaUp_Controllers_User__apiListUnsolvedProblems:
 8922    """_OmegaUp_Controllers_User__apiListUnsolvedProblems"""
 8923    problems: Sequence['_Problem']
 8924
 8925    def __init__(
 8926        self,
 8927        *,
 8928        problems: Sequence[Dict[str, Any]],
 8929        # Ignore any unknown arguments
 8930        **_kwargs: Any,
 8931    ):
 8932        self.problems = [_Problem(**v) for v in problems]
 8933
 8934
 8935@dataclasses.dataclass
 8936class _OmegaUp_Controllers_User__apiLogin:
 8937    """_OmegaUp_Controllers_User__apiLogin"""
 8938    auth_token: str
 8939
 8940    def __init__(
 8941        self,
 8942        *,
 8943        auth_token: str,
 8944        # Ignore any unknown arguments
 8945        **_kwargs: Any,
 8946    ):
 8947        self.auth_token = auth_token
 8948
 8949
 8950@dataclasses.dataclass
 8951class _OmegaUp_Controllers_User__apiMailingListBackfill:
 8952    """_OmegaUp_Controllers_User__apiMailingListBackfill"""
 8953    users: Dict[str, bool]
 8954
 8955    def __init__(
 8956        self,
 8957        *,
 8958        users: Dict[str, bool],
 8959        # Ignore any unknown arguments
 8960        **_kwargs: Any,
 8961    ):
 8962        self.users = {k: v for k, v in users.items()}
 8963
 8964
 8965@dataclasses.dataclass
 8966class _OmegaUp_Controllers_User__apiProblemsCreated:
 8967    """_OmegaUp_Controllers_User__apiProblemsCreated"""
 8968    problems: Sequence['_Problem']
 8969
 8970    def __init__(
 8971        self,
 8972        *,
 8973        problems: Sequence[Dict[str, Any]],
 8974        # Ignore any unknown arguments
 8975        **_kwargs: Any,
 8976    ):
 8977        self.problems = [_Problem(**v) for v in problems]
 8978
 8979
 8980@dataclasses.dataclass
 8981class _OmegaUp_Controllers_User__apiProblemsSolved:
 8982    """_OmegaUp_Controllers_User__apiProblemsSolved"""
 8983    problems: Sequence['_Problem']
 8984
 8985    def __init__(
 8986        self,
 8987        *,
 8988        problems: Sequence[Dict[str, Any]],
 8989        # Ignore any unknown arguments
 8990        **_kwargs: Any,
 8991    ):
 8992        self.problems = [_Problem(**v) for v in problems]
 8993
 8994
 8995@dataclasses.dataclass
 8996class _OmegaUp_Controllers_User__apiStats:
 8997    """_OmegaUp_Controllers_User__apiStats"""
 8998    runs: Sequence['_UserProfileStats']
 8999
 9000    def __init__(
 9001        self,
 9002        *,
 9003        runs: Sequence[Dict[str, Any]],
 9004        # Ignore any unknown arguments
 9005        **_kwargs: Any,
 9006    ):
 9007        self.runs = [_UserProfileStats(**v) for v in runs]
 9008
 9009
 9010@dataclasses.dataclass
 9011class _OmegaUp_Controllers_User__apiStatusVerified:
 9012    """_OmegaUp_Controllers_User__apiStatusVerified"""
 9013    username: str
 9014    verified: bool
 9015
 9016    def __init__(
 9017        self,
 9018        *,
 9019        username: str,
 9020        verified: bool,
 9021        # Ignore any unknown arguments
 9022        **_kwargs: Any,
 9023    ):
 9024        self.username = username
 9025        self.verified = verified
 9026
 9027
 9028@dataclasses.dataclass
 9029class _OmegaUp_Controllers_User__apiValidateFilter:
 9030    """_OmegaUp_Controllers_User__apiValidateFilter"""
 9031    admin: bool
 9032    contest_admin: Sequence[str]
 9033    problem_admin: Sequence[str]
 9034    problemset_admin: Sequence[int]
 9035    user: Optional[str]
 9036
 9037    def __init__(
 9038        self,
 9039        *,
 9040        admin: bool,
 9041        contest_admin: Sequence[str],
 9042        problem_admin: Sequence[str],
 9043        problemset_admin: Sequence[int],
 9044        user: Optional[str] = None,
 9045        # Ignore any unknown arguments
 9046        **_kwargs: Any,
 9047    ):
 9048        self.admin = admin
 9049        self.contest_admin = [v for v in contest_admin]
 9050        self.problem_admin = [v for v in problem_admin]
 9051        self.problemset_admin = [v for v in problemset_admin]
 9052        if user is not None:
 9053            self.user = user
 9054        else:
 9055            self.user = None
 9056
 9057
 9058@dataclasses.dataclass
 9059class _PageItem:
 9060    """_PageItem"""
 9061    class_: str
 9062    label: str
 9063    page: int
 9064    url: Optional[str]
 9065
 9066    def __init__(
 9067        self,
 9068        *,
 9069        label: str,
 9070        page: int,
 9071        url: Optional[str] = None,
 9072        # Ignore any unknown arguments
 9073        **_kwargs: Any,
 9074    ):
 9075        self.class_ = _kwargs['class']
 9076        self.label = label
 9077        self.page = page
 9078        if url is not None:
 9079            self.url = url
 9080        else:
 9081            self.url = None
 9082
 9083
 9084@dataclasses.dataclass
 9085class _Participant:
 9086    """_Participant"""
 9087    country_id: Optional[str]
 9088    gender: Optional[str]
 9089    name: Optional[str]
 9090    participant_password: Optional[str]
 9091    participant_username: str
 9092    password: Optional[str]
 9093    school_name: Optional[str]
 9094    state_id: Optional[str]
 9095    username: str
 9096
 9097    def __init__(
 9098        self,
 9099        *,
 9100        participant_username: str,
 9101        username: str,
 9102        country_id: Optional[str] = None,
 9103        gender: Optional[str] = None,
 9104        name: Optional[str] = None,
 9105        participant_password: Optional[str] = None,
 9106        password: Optional[str] = None,
 9107        school_name: Optional[str] = None,
 9108        state_id: Optional[str] = None,
 9109        # Ignore any unknown arguments
 9110        **_kwargs: Any,
 9111    ):
 9112        if country_id is not None:
 9113            self.country_id = country_id
 9114        else:
 9115            self.country_id = None
 9116        if gender is not None:
 9117            self.gender = gender
 9118        else:
 9119            self.gender = None
 9120        if name is not None:
 9121            self.name = name
 9122        else:
 9123            self.name = None
 9124        if participant_password is not None:
 9125            self.participant_password = participant_password
 9126        else:
 9127            self.participant_password = None
 9128        self.participant_username = participant_username
 9129        if password is not None:
 9130            self.password = password
 9131        else:
 9132            self.password = None
 9133        if school_name is not None:
 9134            self.school_name = school_name
 9135        else:
 9136            self.school_name = None
 9137        if state_id is not None:
 9138            self.state_id = state_id
 9139        else:
 9140            self.state_id = None
 9141        self.username = username
 9142
 9143
 9144@dataclasses.dataclass
 9145class _PrivacyPolicyDetailsPayload:
 9146    """_PrivacyPolicyDetailsPayload"""
 9147    git_object_id: str
 9148    has_accepted: bool
 9149    policy_markdown: str
 9150    statement_type: str
 9151
 9152    def __init__(
 9153        self,
 9154        *,
 9155        git_object_id: str,
 9156        has_accepted: bool,
 9157        policy_markdown: str,
 9158        statement_type: str,
 9159        # Ignore any unknown arguments
 9160        **_kwargs: Any,
 9161    ):
 9162        self.git_object_id = git_object_id
 9163        self.has_accepted = has_accepted
 9164        self.policy_markdown = policy_markdown
 9165        self.statement_type = statement_type
 9166
 9167
 9168@dataclasses.dataclass
 9169class _PrivacyStatement:
 9170    """_PrivacyStatement"""
 9171    gitObjectId: Optional[str]
 9172    markdown: str
 9173    statementType: str
 9174
 9175    def __init__(
 9176        self,
 9177        *,
 9178        markdown: str,
 9179        statementType: str,
 9180        gitObjectId: Optional[str] = None,
 9181        # Ignore any unknown arguments
 9182        **_kwargs: Any,
 9183    ):
 9184        if gitObjectId is not None:
 9185            self.gitObjectId = gitObjectId
 9186        else:
 9187            self.gitObjectId = None
 9188        self.markdown = markdown
 9189        self.statementType = statementType
 9190
 9191
 9192@dataclasses.dataclass
 9193class _Problem:
 9194    """_Problem"""
 9195    accepted: int
 9196    alias: str
 9197    difficulty: float
 9198    quality_seal: bool
 9199    submissions: int
 9200    title: str
 9201
 9202    def __init__(
 9203        self,
 9204        *,
 9205        accepted: int,
 9206        alias: str,
 9207        difficulty: float,
 9208        quality_seal: bool,
 9209        submissions: int,
 9210        title: str,
 9211        # Ignore any unknown arguments
 9212        **_kwargs: Any,
 9213    ):
 9214        self.accepted = accepted
 9215        self.alias = alias
 9216        self.difficulty = difficulty
 9217        self.quality_seal = quality_seal
 9218        self.submissions = submissions
 9219        self.title = title
 9220
 9221
 9222@dataclasses.dataclass
 9223class _ProblemAdmin:
 9224    """_ProblemAdmin"""
 9225    role: str
 9226    username: str
 9227
 9228    def __init__(
 9229        self,
 9230        *,
 9231        role: str,
 9232        username: str,
 9233        # Ignore any unknown arguments
 9234        **_kwargs: Any,
 9235    ):
 9236        self.role = role
 9237        self.username = username
 9238
 9239
 9240@dataclasses.dataclass
 9241class _ProblemCasesContents_value:
 9242    """_ProblemCasesContents_value"""
 9243    contestantOutput: Optional[str]
 9244    in_: str
 9245    out: str
 9246
 9247    def __init__(
 9248        self,
 9249        *,
 9250        out: str,
 9251        contestantOutput: Optional[str] = None,
 9252        # Ignore any unknown arguments
 9253        **_kwargs: Any,
 9254    ):
 9255        if contestantOutput is not None:
 9256            self.contestantOutput = contestantOutput
 9257        else:
 9258            self.contestantOutput = None
 9259        self.in_ = _kwargs['in']
 9260        self.out = out
 9261
 9262
 9263@dataclasses.dataclass
 9264class _ProblemDetails:
 9265    """_ProblemDetails"""
 9266    accepted: int
 9267    accepts_submissions: bool
 9268    admin: Optional[bool]
 9269    alias: str
 9270    allow_user_add_tags: bool
 9271    commit: str
 9272    creation_date: datetime.datetime
 9273    difficulty: Optional[float]
 9274    email_clarifications: bool
 9275    input_limit: int
 9276    karel_problem: bool
 9277    languages: Sequence[str]
 9278    letter: Optional[str]
 9279    limits: '_SettingLimits'
 9280    nextSubmissionTimestamp: Optional[datetime.datetime]
 9281    nominationStatus: '_NominationStatus'
 9282    order: str
 9283    points: float
 9284    preferred_language: Optional[str]
 9285    problem_id: int
 9286    problemsetter: Optional['_ProblemsetterInfo']
 9287    quality_seal: bool
 9288    runs: Optional[Sequence['_RunWithDetails']]
 9289    score: float
 9290    settings: '_ProblemSettingsDistrib'
 9291    show_diff: str
 9292    solvers: Optional[Sequence['_BestSolvers']]
 9293    source: Optional[str]
 9294    statement: '_ProblemStatement'
 9295    submissions: int
 9296    title: str
 9297    version: str
 9298    visibility: int
 9299    visits: int
 9300
 9301    def __init__(
 9302        self,
 9303        *,
 9304        accepted: int,
 9305        accepts_submissions: bool,
 9306        alias: str,
 9307        allow_user_add_tags: bool,
 9308        commit: str,
 9309        creation_date: int,
 9310        email_clarifications: bool,
 9311        input_limit: int,
 9312        karel_problem: bool,
 9313        languages: Sequence[str],
 9314        limits: Dict[str, Any],
 9315        nominationStatus: Dict[str, Any],
 9316        order: str,
 9317        points: float,
 9318        problem_id: int,
 9319        quality_seal: bool,
 9320        score: float,
 9321        settings: Dict[str, Any],
 9322        show_diff: str,
 9323        statement: Dict[str, Any],
 9324        submissions: int,
 9325        title: str,
 9326        version: str,
 9327        visibility: int,
 9328        visits: int,
 9329        admin: Optional[bool] = None,
 9330        difficulty: Optional[float] = None,
 9331        letter: Optional[str] = None,
 9332        nextSubmissionTimestamp: Optional[int] = None,
 9333        preferred_language: Optional[str] = None,
 9334        problemsetter: Optional[Dict[str, Any]] = None,
 9335        runs: Optional[Sequence[Dict[str, Any]]] = None,
 9336        solvers: Optional[Sequence[Dict[str, Any]]] = None,
 9337        source: Optional[str] = None,
 9338        # Ignore any unknown arguments
 9339        **_kwargs: Any,
 9340    ):
 9341        self.accepted = accepted
 9342        self.accepts_submissions = accepts_submissions
 9343        if admin is not None:
 9344            self.admin = admin
 9345        else:
 9346            self.admin = None
 9347        self.alias = alias
 9348        self.allow_user_add_tags = allow_user_add_tags
 9349        self.commit = commit
 9350        self.creation_date = datetime.datetime.fromtimestamp(creation_date)
 9351        if difficulty is not None:
 9352            self.difficulty = difficulty
 9353        else:
 9354            self.difficulty = None
 9355        self.email_clarifications = email_clarifications
 9356        self.input_limit = input_limit
 9357        self.karel_problem = karel_problem
 9358        self.languages = [v for v in languages]
 9359        if letter is not None:
 9360            self.letter = letter
 9361        else:
 9362            self.letter = None
 9363        self.limits = _SettingLimits(**limits)
 9364        if nextSubmissionTimestamp is not None:
 9365            self.nextSubmissionTimestamp = datetime.datetime.fromtimestamp(
 9366                nextSubmissionTimestamp)
 9367        else:
 9368            self.nextSubmissionTimestamp = None
 9369        self.nominationStatus = _NominationStatus(**nominationStatus)
 9370        self.order = order
 9371        self.points = points
 9372        if preferred_language is not None:
 9373            self.preferred_language = preferred_language
 9374        else:
 9375            self.preferred_language = None
 9376        self.problem_id = problem_id
 9377        if problemsetter is not None:
 9378            self.problemsetter = _ProblemsetterInfo(**problemsetter)
 9379        else:
 9380            self.problemsetter = None
 9381        self.quality_seal = quality_seal
 9382        if runs is not None:
 9383            self.runs = [_RunWithDetails(**v) for v in runs]
 9384        else:
 9385            self.runs = None
 9386        self.score = score
 9387        self.settings = _ProblemSettingsDistrib(**settings)
 9388        self.show_diff = show_diff
 9389        if solvers is not None:
 9390            self.solvers = [_BestSolvers(**v) for v in solvers]
 9391        else:
 9392            self.solvers = None
 9393        if source is not None:
 9394            self.source = source
 9395        else:
 9396            self.source = None
 9397        self.statement = _ProblemStatement(**statement)
 9398        self.submissions = submissions
 9399        self.title = title
 9400        self.version = version
 9401        self.visibility = visibility
 9402        self.visits = visits
 9403
 9404
 9405@dataclasses.dataclass
 9406class _ProblemDetailsPayload:
 9407    """_ProblemDetailsPayload"""
 9408    allRuns: Optional[Sequence['_Run']]
 9409    allowUserAddTags: Optional[bool]
 9410    clarifications: Optional[Sequence['_Clarification']]
 9411    histogram: '_Histogram'
 9412    levelTags: Optional[Sequence[str]]
 9413    nominationStatus: Optional['_NominationStatus']
 9414    problem: '_ProblemInfo'
 9415    problemLevel: Optional[str]
 9416    publicTags: Optional[Sequence[str]]
 9417    runs: Optional[Sequence['_Run']]
 9418    selectedPrivateTags: Optional[Sequence[str]]
 9419    selectedPublicTags: Optional[Sequence[str]]
 9420    solutionStatus: Optional[str]
 9421    solvers: Sequence['_BestSolvers']
 9422    totalRuns: Optional[int]
 9423    user: '_UserInfoForProblem'
 9424
 9425    def __init__(
 9426        self,
 9427        *,
 9428        histogram: Dict[str, Any],
 9429        problem: Dict[str, Any],
 9430        solvers: Sequence[Dict[str, Any]],
 9431        user: Dict[str, Any],
 9432        allRuns: Optional[Sequence[Dict[str, Any]]] = None,
 9433        allowUserAddTags: Optional[bool] = None,
 9434        clarifications: Optional[Sequence[Dict[str, Any]]] = None,
 9435        levelTags: Optional[Sequence[str]] = None,
 9436        nominationStatus: Optional[Dict[str, Any]] = None,
 9437        problemLevel: Optional[str] = None,
 9438        publicTags: Optional[Sequence[str]] = None,
 9439        runs: Optional[Sequence[Dict[str, Any]]] = None,
 9440        selectedPrivateTags: Optional[Sequence[str]] = None,
 9441        selectedPublicTags: Optional[Sequence[str]] = None,
 9442        solutionStatus: Optional[str] = None,
 9443        totalRuns: Optional[int] = None,
 9444        # Ignore any unknown arguments
 9445        **_kwargs: Any,
 9446    ):
 9447        if allRuns is not None:
 9448            self.allRuns = [_Run(**v) for v in allRuns]
 9449        else:
 9450            self.allRuns = None
 9451        if allowUserAddTags is not None:
 9452            self.allowUserAddTags = allowUserAddTags
 9453        else:
 9454            self.allowUserAddTags = None
 9455        if clarifications is not None:
 9456            self.clarifications = [_Clarification(**v) for v in clarifications]
 9457        else:
 9458            self.clarifications = None
 9459        self.histogram = _Histogram(**histogram)
 9460        if levelTags is not None:
 9461            self.levelTags = [v for v in levelTags]
 9462        else:
 9463            self.levelTags = None
 9464        if nominationStatus is not None:
 9465            self.nominationStatus = _NominationStatus(**nominationStatus)
 9466        else:
 9467            self.nominationStatus = None
 9468        self.problem = _ProblemInfo(**problem)
 9469        if problemLevel is not None:
 9470            self.problemLevel = problemLevel
 9471        else:
 9472            self.problemLevel = None
 9473        if publicTags is not None:
 9474            self.publicTags = [v for v in publicTags]
 9475        else:
 9476            self.publicTags = None
 9477        if runs is not None:
 9478            self.runs = [_Run(**v) for v in runs]
 9479        else:
 9480            self.runs = None
 9481        if selectedPrivateTags is not None:
 9482            self.selectedPrivateTags = [v for v in selectedPrivateTags]
 9483        else:
 9484            self.selectedPrivateTags = None
 9485        if selectedPublicTags is not None:
 9486            self.selectedPublicTags = [v for v in selectedPublicTags]
 9487        else:
 9488            self.selectedPublicTags = None
 9489        if solutionStatus is not None:
 9490            self.solutionStatus = solutionStatus
 9491        else:
 9492            self.solutionStatus = None
 9493        self.solvers = [_BestSolvers(**v) for v in solvers]
 9494        if totalRuns is not None:
 9495            self.totalRuns = totalRuns
 9496        else:
 9497            self.totalRuns = None
 9498        self.user = _UserInfoForProblem(**user)
 9499
 9500
 9501@dataclasses.dataclass
 9502class _ProblemEditPayload:
 9503    """_ProblemEditPayload"""
 9504    admins: Sequence['_ProblemAdmin']
 9505    alias: str
 9506    allowUserAddTags: bool
 9507    emailClarifications: bool
 9508    extraWallTime: float
 9509    groupAdmins: Sequence['_ProblemGroupAdmin']
 9510    groupScorePolicy: Optional[str]
 9511    inputLimit: int
 9512    languages: str
 9513    levelTags: Sequence[str]
 9514    log: Sequence['_ProblemVersion']
 9515    memoryLimit: float
 9516    outputLimit: int
 9517    overallWallTimeLimit: float
 9518    problemLevel: Optional[str]
 9519    problemsetter: Optional['_ProblemsetterInfo']
 9520    publicTags: Sequence[str]
 9521    publishedRevision: Optional['_ProblemVersion']
 9522    selectedPrivateTags: Sequence[str]
 9523    selectedPublicTags: Sequence[str]
 9524    showDiff: str
 9525    solution: Optional['_ProblemStatement']
 9526    source: str
 9527    statement: '_ProblemStatement'
 9528    statusError: Optional[str]
 9529    statusSuccess: bool
 9530    timeLimit: float
 9531    title: str
 9532    validLanguages: Dict[str, str]
 9533    validator: str
 9534    validatorTimeLimit: Union[float, int]
 9535    validatorTypes: Dict[str, Optional[str]]
 9536    visibility: int
 9537    visibilityStatuses: Dict[str, int]
 9538
 9539    def __init__(
 9540        self,
 9541        *,
 9542        admins: Sequence[Dict[str, Any]],
 9543        alias: str,
 9544        allowUserAddTags: bool,
 9545        emailClarifications: bool,
 9546        extraWallTime: float,
 9547        groupAdmins: Sequence[Dict[str, Any]],
 9548        inputLimit: int,
 9549        languages: str,
 9550        levelTags: Sequence[str],
 9551        log: Sequence[Dict[str, Any]],
 9552        memoryLimit: float,
 9553        outputLimit: int,
 9554        overallWallTimeLimit: float,
 9555        publicTags: Sequence[str],
 9556        selectedPrivateTags: Sequence[str],
 9557        selectedPublicTags: Sequence[str],
 9558        showDiff: str,
 9559        source: str,
 9560        statement: Dict[str, Any],
 9561        statusSuccess: bool,
 9562        timeLimit: float,
 9563        title: str,
 9564        validLanguages: Dict[str, str],
 9565        validator: str,
 9566        validatorTimeLimit: Union[float, int],
 9567        validatorTypes: Dict[str, Optional[str]],
 9568        visibility: int,
 9569        visibilityStatuses: Dict[str, int],
 9570        groupScorePolicy: Optional[str] = None,
 9571        problemLevel: Optional[str] = None,
 9572        problemsetter: Optional[Dict[str, Any]] = None,
 9573        publishedRevision: Optional[Dict[str, Any]] = None,
 9574        solution: Optional[Dict[str, Any]] = None,
 9575        statusError: Optional[str] = None,
 9576        # Ignore any unknown arguments
 9577        **_kwargs: Any,
 9578    ):
 9579        self.admins = [_ProblemAdmin(**v) for v in admins]
 9580        self.alias = alias
 9581        self.allowUserAddTags = allowUserAddTags
 9582        self.emailClarifications = emailClarifications
 9583        self.extraWallTime = extraWallTime
 9584        self.groupAdmins = [_ProblemGroupAdmin(**v) for v in groupAdmins]
 9585        if groupScorePolicy is not None:
 9586            self.groupScorePolicy = groupScorePolicy
 9587        else:
 9588            self.groupScorePolicy = None
 9589        self.inputLimit = inputLimit
 9590        self.languages = languages
 9591        self.levelTags = [v for v in levelTags]
 9592        self.log = [_ProblemVersion(**v) for v in log]
 9593        self.memoryLimit = memoryLimit
 9594        self.outputLimit = outputLimit
 9595        self.overallWallTimeLimit = overallWallTimeLimit
 9596        if problemLevel is not None:
 9597            self.problemLevel = problemLevel
 9598        else:
 9599            self.problemLevel = None
 9600        if problemsetter is not None:
 9601            self.problemsetter = _ProblemsetterInfo(**problemsetter)
 9602        else:
 9603            self.problemsetter = None
 9604        self.publicTags = [v for v in publicTags]
 9605        if publishedRevision is not None:
 9606            self.publishedRevision = _ProblemVersion(**publishedRevision)
 9607        else:
 9608            self.publishedRevision = None
 9609        self.selectedPrivateTags = [v for v in selectedPrivateTags]
 9610        self.selectedPublicTags = [v for v in selectedPublicTags]
 9611        self.showDiff = showDiff
 9612        if solution is not None:
 9613            self.solution = _ProblemStatement(**solution)
 9614        else:
 9615            self.solution = None
 9616        self.source = source
 9617        self.statement = _ProblemStatement(**statement)
 9618        if statusError is not None:
 9619            self.statusError = statusError
 9620        else:
 9621            self.statusError = None
 9622        self.statusSuccess = statusSuccess
 9623        self.timeLimit = timeLimit
 9624        self.title = title
 9625        self.validLanguages = {k: v for k, v in validLanguages.items()}
 9626        self.validator = validator
 9627        self.validatorTimeLimit = validatorTimeLimit
 9628        self.validatorTypes = {
 9629            k: v if v is not None else None
 9630            for k, v in validatorTypes.items()
 9631        }
 9632        self.visibility = visibility
 9633        self.visibilityStatuses = {k: v for k, v in visibilityStatuses.items()}
 9634
 9635
 9636@dataclasses.dataclass
 9637class _ProblemFormPayload:
 9638    """_ProblemFormPayload"""
 9639    alias: str
 9640    allowUserAddTags: bool
 9641    emailClarifications: bool
 9642    extraWallTime: Union[int, str]
 9643    groupScorePolicy: Optional[str]
 9644    inputLimit: Union[int, str]
 9645    languages: str
 9646    levelTags: Sequence[str]
 9647    memoryLimit: Union[int, str]
 9648    message: Optional[str]
 9649    outputLimit: Union[int, str]
 9650    overallWallTimeLimit: Union[int, str]
 9651    parameter: Optional[str]
 9652    problem_level: str
 9653    publicTags: Sequence[str]
 9654    selectedTags: Optional[Sequence['_SelectedTag']]
 9655    showDiff: str
 9656    source: str
 9657    statusError: str
 9658    tags: Sequence['_ProblemFormPayload_tags_entry']
 9659    timeLimit: Union[int, str]
 9660    title: str
 9661    validLanguages: Dict[str, str]
 9662    validator: str
 9663    validatorTimeLimit: Union[int, str]
 9664    validatorTypes: Dict[str, Optional[str]]
 9665    visibility: int
 9666    visibilityStatuses: Dict[str, int]
 9667
 9668    def __init__(
 9669        self,
 9670        *,
 9671        alias: str,
 9672        allowUserAddTags: bool,
 9673        emailClarifications: bool,
 9674        extraWallTime: Union[int, str],
 9675        inputLimit: Union[int, str],
 9676        languages: str,
 9677        levelTags: Sequence[str],
 9678        memoryLimit: Union[int, str],
 9679        outputLimit: Union[int, str],
 9680        overallWallTimeLimit: Union[int, str],
 9681        problem_level: str,
 9682        publicTags: Sequence[str],
 9683        showDiff: str,
 9684        source: str,
 9685        statusError: str,
 9686        tags: Sequence[Dict[str, Any]],
 9687        timeLimit: Union[int, str],
 9688        title: str,
 9689        validLanguages: Dict[str, str],
 9690        validator: str,
 9691        validatorTimeLimit: Union[int, str],
 9692        validatorTypes: Dict[str, Optional[str]],
 9693        visibility: int,
 9694        visibilityStatuses: Dict[str, int],
 9695        groupScorePolicy: Optional[str] = None,
 9696        message: Optional[str] = None,
 9697        parameter: Optional[str] = None,
 9698        selectedTags: Optional[Sequence[Dict[str, Any]]] = None,
 9699        # Ignore any unknown arguments
 9700        **_kwargs: Any,
 9701    ):
 9702        self.alias = alias
 9703        self.allowUserAddTags = allowUserAddTags
 9704        self.emailClarifications = emailClarifications
 9705        self.extraWallTime = extraWallTime
 9706        if groupScorePolicy is not None:
 9707            self.groupScorePolicy = groupScorePolicy
 9708        else:
 9709            self.groupScorePolicy = None
 9710        self.inputLimit = inputLimit
 9711        self.languages = languages
 9712        self.levelTags = [v for v in levelTags]
 9713        self.memoryLimit = memoryLimit
 9714        if message is not None:
 9715            self.message = message
 9716        else:
 9717            self.message = None
 9718        self.outputLimit = outputLimit
 9719        self.overallWallTimeLimit = overallWallTimeLimit
 9720        if parameter is not None:
 9721            self.parameter = parameter
 9722        else:
 9723            self.parameter = None
 9724        self.problem_level = problem_level
 9725        self.publicTags = [v for v in publicTags]
 9726        if selectedTags is not None:
 9727            self.selectedTags = [_SelectedTag(**v) for v in selectedTags]
 9728        else:
 9729            self.selectedTags = None
 9730        self.showDiff = showDiff
 9731        self.source = source
 9732        self.statusError = statusError
 9733        self.tags = [_ProblemFormPayload_tags_entry(**v) for v in tags]
 9734        self.timeLimit = timeLimit
 9735        self.title = title
 9736        self.validLanguages = {k: v for k, v in validLanguages.items()}
 9737        self.validator = validator
 9738        self.validatorTimeLimit = validatorTimeLimit
 9739        self.validatorTypes = {
 9740            k: v if v is not None else None
 9741            for k, v in validatorTypes.items()
 9742        }
 9743        self.visibility = visibility
 9744        self.visibilityStatuses = {k: v for k, v in visibilityStatuses.items()}
 9745
 9746
 9747@dataclasses.dataclass
 9748class _ProblemFormPayload_tags_entry:
 9749    """_ProblemFormPayload_tags_entry"""
 9750    name: Optional[str]
 9751
 9752    def __init__(
 9753        self,
 9754        *,
 9755        name: Optional[str] = None,
 9756        # Ignore any unknown arguments
 9757        **_kwargs: Any,
 9758    ):
 9759        if name is not None:
 9760            self.name = name
 9761        else:
 9762            self.name = None
 9763
 9764
 9765@dataclasses.dataclass
 9766class _ProblemGroupAdmin:
 9767    """_ProblemGroupAdmin"""
 9768    alias: str
 9769    name: str
 9770    role: str
 9771
 9772    def __init__(
 9773        self,
 9774        *,
 9775        alias: str,
 9776        name: str,
 9777        role: str,
 9778        # Ignore any unknown arguments
 9779        **_kwargs: Any,
 9780    ):
 9781        self.alias = alias
 9782        self.name = name
 9783        self.role = role
 9784
 9785
 9786@dataclasses.dataclass
 9787class _ProblemInfo:
 9788    """_ProblemInfo"""
 9789    accepts_submissions: bool
 9790    alias: str
 9791    commit: str
 9792    input_limit: int
 9793    karel_problem: bool
 9794    languages: Sequence[str]
 9795    letter: Optional[str]
 9796    limits: '_SettingLimits'
 9797    nextSubmissionTimestamp: Optional[datetime.datetime]
 9798    points: float
 9799    preferred_language: Optional[str]
 9800    problem_id: int
 9801    problemsetter: Optional['_ProblemsetterInfo']
 9802    quality_seal: bool
 9803    sample_input: Optional[str]
 9804    settings: '_ProblemSettingsDistrib'
 9805    source: Optional[str]
 9806    statement: '_ProblemStatement'
 9807    title: str
 9808    visibility: int
 9809
 9810    def __init__(
 9811        self,
 9812        *,
 9813        accepts_submissions: bool,
 9814        alias: str,
 9815        commit: str,
 9816        input_limit: int,
 9817        karel_problem: bool,
 9818        languages: Sequence[str],
 9819        limits: Dict[str, Any],
 9820        points: float,
 9821        problem_id: int,
 9822        quality_seal: bool,
 9823        settings: Dict[str, Any],
 9824        statement: Dict[str, Any],
 9825        title: str,
 9826        visibility: int,
 9827        letter: Optional[str] = None,
 9828        nextSubmissionTimestamp: Optional[int] = None,
 9829        preferred_language: Optional[str] = None,
 9830        problemsetter: Optional[Dict[str, Any]] = None,
 9831        sample_input: Optional[str] = None,
 9832        source: Optional[str] = None,
 9833        # Ignore any unknown arguments
 9834        **_kwargs: Any,
 9835    ):
 9836        self.accepts_submissions = accepts_submissions
 9837        self.alias = alias
 9838        self.commit = commit
 9839        self.input_limit = input_limit
 9840        self.karel_problem = karel_problem
 9841        self.languages = [v for v in languages]
 9842        if letter is not None:
 9843            self.letter = letter
 9844        else:
 9845            self.letter = None
 9846        self.limits = _SettingLimits(**limits)
 9847        if nextSubmissionTimestamp is not None:
 9848            self.nextSubmissionTimestamp = datetime.datetime.fromtimestamp(
 9849                nextSubmissionTimestamp)
 9850        else:
 9851            self.nextSubmissionTimestamp = None
 9852        self.points = points
 9853        if preferred_language is not None:
 9854            self.preferred_language = preferred_language
 9855        else:
 9856            self.preferred_language = None
 9857        self.problem_id = problem_id
 9858        if problemsetter is not None:
 9859            self.problemsetter = _ProblemsetterInfo(**problemsetter)
 9860        else:
 9861            self.problemsetter = None
 9862        self.quality_seal = quality_seal
 9863        if sample_input is not None:
 9864            self.sample_input = sample_input
 9865        else:
 9866            self.sample_input = None
 9867        self.settings = _ProblemSettingsDistrib(**settings)
 9868        if source is not None:
 9869            self.source = source
 9870        else:
 9871            self.source = None
 9872        self.statement = _ProblemStatement(**statement)
 9873        self.title = title
 9874        self.visibility = visibility
 9875
 9876
 9877@dataclasses.dataclass
 9878class _ProblemListCollectionPayload:
 9879    """_ProblemListCollectionPayload"""
 9880    allTags: Sequence['_Tag']
 9881    levelTags: Sequence[str]
 9882    problemCount: Sequence['_ProblemListCollectionPayload_problemCount_entry']
 9883
 9884    def __init__(
 9885        self,
 9886        *,
 9887        allTags: Sequence[Dict[str, Any]],
 9888        levelTags: Sequence[str],
 9889        problemCount: Sequence[Dict[str, Any]],
 9890        # Ignore any unknown arguments
 9891        **_kwargs: Any,
 9892    ):
 9893        self.allTags = [_Tag(**v) for v in allTags]
 9894        self.levelTags = [v for v in levelTags]
 9895        self.problemCount = [
 9896            _ProblemListCollectionPayload_problemCount_entry(**v)
 9897            for v in problemCount
 9898        ]
 9899
 9900
 9901@dataclasses.dataclass
 9902class _ProblemListCollectionPayload_problemCount_entry:
 9903    """_ProblemListCollectionPayload_problemCount_entry"""
 9904    name: str
 9905    problems_per_tag: int
 9906
 9907    def __init__(
 9908        self,
 9909        *,
 9910        name: str,
 9911        problems_per_tag: int,
 9912        # Ignore any unknown arguments
 9913        **_kwargs: Any,
 9914    ):
 9915        self.name = name
 9916        self.problems_per_tag = problems_per_tag
 9917
 9918
 9919@dataclasses.dataclass
 9920class _ProblemListItem:
 9921    """_ProblemListItem"""
 9922    alias: str
 9923    difficulty: Optional[float]
 9924    difficulty_histogram: Sequence[int]
 9925    points: float
 9926    problem_id: int
 9927    quality: Optional[float]
 9928    quality_histogram: Sequence[int]
 9929    quality_seal: bool
 9930    ratio: float
 9931    score: float
 9932    tags: Sequence['_ProblemListItem_tags_entry']
 9933    title: str
 9934    visibility: int
 9935
 9936    def __init__(
 9937        self,
 9938        *,
 9939        alias: str,
 9940        difficulty_histogram: Sequence[int],
 9941        points: float,
 9942        problem_id: int,
 9943        quality_histogram: Sequence[int],
 9944        quality_seal: bool,
 9945        ratio: float,
 9946        score: float,
 9947        tags: Sequence[Dict[str, Any]],
 9948        title: str,
 9949        visibility: int,
 9950        difficulty: Optional[float] = None,
 9951        quality: Optional[float] = None,
 9952        # Ignore any unknown arguments
 9953        **_kwargs: Any,
 9954    ):
 9955        self.alias = alias
 9956        if difficulty is not None:
 9957            self.difficulty = difficulty
 9958        else:
 9959            self.difficulty = None
 9960        self.difficulty_histogram = [v for v in difficulty_histogram]
 9961        self.points = points
 9962        self.problem_id = problem_id
 9963        if quality is not None:
 9964            self.quality = quality
 9965        else:
 9966            self.quality = None
 9967        self.quality_histogram = [v for v in quality_histogram]
 9968        self.quality_seal = quality_seal
 9969        self.ratio = ratio
 9970        self.score = score
 9971        self.tags = [_ProblemListItem_tags_entry(**v) for v in tags]
 9972        self.title = title
 9973        self.visibility = visibility
 9974
 9975
 9976@dataclasses.dataclass
 9977class _ProblemListItem_tags_entry:
 9978    """_ProblemListItem_tags_entry"""
 9979    name: str
 9980    source: str
 9981
 9982    def __init__(
 9983        self,
 9984        *,
 9985        name: str,
 9986        source: str,
 9987        # Ignore any unknown arguments
 9988        **_kwargs: Any,
 9989    ):
 9990        self.name = name
 9991        self.source = source
 9992
 9993
 9994@dataclasses.dataclass
 9995class _ProblemListPayload:
 9996    """_ProblemListPayload"""
 9997    column: str
 9998    columns: Sequence[str]
 9999    keyword: str
10000    language: str
10001    languages: Sequence[str]
10002    loggedIn: bool
10003    mode: str
10004    modes: Sequence[str]
10005    pagerItems: Sequence['_PageItem']
10006    problems: Sequence['_ProblemListItem']
10007    selectedTags: Sequence[str]
10008    tagData: Sequence['_ProblemListPayload_tagData_entry']
10009    tags: Sequence[str]
10010
10011    def __init__(
10012        self,
10013        *,
10014        column: str,
10015        columns: Sequence[str],
10016        keyword: str,
10017        language: str,
10018        languages: Sequence[str],
10019        loggedIn: bool,
10020        mode: str,
10021        modes: Sequence[str],
10022        pagerItems: Sequence[Dict[str, Any]],
10023        problems: Sequence[Dict[str, Any]],
10024        selectedTags: Sequence[str],
10025        tagData: Sequence[Dict[str, Any]],
10026        tags: Sequence[str],
10027        # Ignore any unknown arguments
10028        **_kwargs: Any,
10029    ):
10030        self.column = column
10031        self.columns = [v for v in columns]
10032        self.keyword = keyword
10033        self.language = language
10034        self.languages = [v for v in languages]
10035        self.loggedIn = loggedIn
10036        self.mode = mode
10037        self.modes = [v for v in modes]
10038        self.pagerItems = [_PageItem(**v) for v in pagerItems]
10039        self.problems = [_ProblemListItem(**v) for v in problems]
10040        self.selectedTags = [v for v in selectedTags]
10041        self.tagData = [
10042            _ProblemListPayload_tagData_entry(**v) for v in tagData
10043        ]
10044        self.tags = [v for v in tags]
10045
10046
10047@dataclasses.dataclass
10048class _ProblemListPayload_tagData_entry:
10049    """_ProblemListPayload_tagData_entry"""
10050    name: Optional[str]
10051
10052    def __init__(
10053        self,
10054        *,
10055        name: Optional[str] = None,
10056        # Ignore any unknown arguments
10057        **_kwargs: Any,
10058    ):
10059        if name is not None:
10060            self.name = name
10061        else:
10062            self.name = None
10063
10064
10065@dataclasses.dataclass
10066class _ProblemPrintDetailsPayload:
10067    """_ProblemPrintDetailsPayload"""
10068    details: '_ProblemDetails'
10069
10070    def __init__(
10071        self,
10072        *,
10073        details: Dict[str, Any],
10074        # Ignore any unknown arguments
10075        **_kwargs: Any,
10076    ):
10077        self.details = _ProblemDetails(**details)
10078
10079
10080@dataclasses.dataclass
10081class _ProblemQualityPayload:
10082    """_ProblemQualityPayload"""
10083    canNominateProblem: bool
10084    dismissed: bool
10085    dismissedBeforeAc: bool
10086    language: Optional[str]
10087    nominated: bool
10088    nominatedBeforeAc: bool
10089    problemAlias: str
10090    solved: bool
10091    tried: bool
10092
10093    def __init__(
10094        self,
10095        *,
10096        canNominateProblem: bool,
10097        dismissed: bool,
10098        dismissedBeforeAc: bool,
10099        nominated: bool,
10100        nominatedBeforeAc: bool,
10101        problemAlias: str,
10102        solved: bool,
10103        tried: bool,
10104        language: Optional[str] = None,
10105        # Ignore any unknown arguments
10106        **_kwargs: Any,
10107    ):
10108        self.canNominateProblem = canNominateProblem
10109        self.dismissed = dismissed
10110        self.dismissedBeforeAc = dismissedBeforeAc
10111        if language is not None:
10112            self.language = language
10113        else:
10114            self.language = None
10115        self.nominated = nominated
10116        self.nominatedBeforeAc = nominatedBeforeAc
10117        self.problemAlias = problemAlias
10118        self.solved = solved
10119        self.tried = tried
10120
10121
10122@dataclasses.dataclass
10123class _ProblemSettings:
10124    """_ProblemSettings"""
10125    Cases: Sequence['_ProblemSettings_Cases_entry']
10126    Interactive: Optional['_ProblemSettings_Interactive']
10127    Limits: '_LimitsSettings'
10128    Slow: bool
10129    Validator: '_ProblemSettings_Validator'
10130
10131    def __init__(
10132        self,
10133        *,
10134        Cases: Sequence[Dict[str, Any]],
10135        Limits: Dict[str, Any],
10136        Slow: bool,
10137        Validator: Dict[str, Any],
10138        Interactive: Optional[Dict[str, Any]] = None,
10139        # Ignore any unknown arguments
10140        **_kwargs: Any,
10141    ):
10142        self.Cases = [_ProblemSettings_Cases_entry(**v) for v in Cases]
10143        if Interactive is not None:
10144            self.Interactive = _ProblemSettings_Interactive(**Interactive)
10145        else:
10146            self.Interactive = None
10147        self.Limits = _LimitsSettings(**Limits)
10148        self.Slow = Slow
10149        self.Validator = _ProblemSettings_Validator(**Validator)
10150
10151
10152@dataclasses.dataclass
10153class _ProblemSettingsDistrib:
10154    """_ProblemSettingsDistrib"""
10155    cases: Dict[str, '_ProblemSettingsDistrib_cases_value']
10156    interactive: Optional['_InteractiveSettingsDistrib']
10157    limits: '_LimitsSettings'
10158    validator: '_ProblemSettingsDistrib_validator'
10159
10160    def __init__(
10161        self,
10162        *,
10163        cases: Dict[str, Dict[str, Any]],
10164        limits: Dict[str, Any],
10165        validator: Dict[str, Any],
10166        interactive: Optional[Dict[str, Any]] = None,
10167        # Ignore any unknown arguments
10168        **_kwargs: Any,
10169    ):
10170        self.cases = {
10171            k: _ProblemSettingsDistrib_cases_value(**v)
10172            for k, v in cases.items()
10173        }
10174        if interactive is not None:
10175            self.interactive = _InteractiveSettingsDistrib(**interactive)
10176        else:
10177            self.interactive = None
10178        self.limits = _LimitsSettings(**limits)
10179        self.validator = _ProblemSettingsDistrib_validator(**validator)
10180
10181
10182@dataclasses.dataclass
10183class _ProblemSettingsDistrib_cases_value:
10184    """_ProblemSettingsDistrib_cases_value"""
10185    in_: str
10186    out: str
10187    weight: Optional[float]
10188
10189    def __init__(
10190        self,
10191        *,
10192        out: str,
10193        weight: Optional[float] = None,
10194        # Ignore any unknown arguments
10195        **_kwargs: Any,
10196    ):
10197        self.in_ = _kwargs['in']
10198        self.out = out
10199        if weight is not None:
10200            self.weight = weight
10201        else:
10202            self.weight = None
10203
10204
10205@dataclasses.dataclass
10206class _ProblemSettingsDistrib_validator:
10207    """_ProblemSettingsDistrib_validator"""
10208    custom_validator: Optional[
10209        '_ProblemSettingsDistrib_validator_custom_validator']
10210    group_score_policy: Optional[str]
10211    name: str
10212    tolerance: Optional[float]
10213
10214    def __init__(
10215        self,
10216        *,
10217        name: str,
10218        custom_validator: Optional[Dict[str, Any]] = None,
10219        group_score_policy: Optional[str] = None,
10220        tolerance: Optional[float] = None,
10221        # Ignore any unknown arguments
10222        **_kwargs: Any,
10223    ):
10224        if custom_validator is not None:
10225            self.custom_validator = _ProblemSettingsDistrib_validator_custom_validator(
10226                **custom_validator)
10227        else:
10228            self.custom_validator = None
10229        if group_score_policy is not None:
10230            self.group_score_policy = group_score_policy
10231        else:
10232            self.group_score_policy = None
10233        self.name = name
10234        if tolerance is not None:
10235            self.tolerance = tolerance
10236        else:
10237            self.tolerance = None
10238
10239
10240@dataclasses.dataclass
10241class _ProblemSettingsDistrib_validator_custom_validator:
10242    """_ProblemSettingsDistrib_validator_custom_validator"""
10243    language: str
10244    limits: Optional['_LimitsSettings']
10245    source: str
10246
10247    def __init__(
10248        self,
10249        *,
10250        language: str,
10251        source: str,
10252        limits: Optional[Dict[str, Any]] = None,
10253        # Ignore any unknown arguments
10254        **_kwargs: Any,
10255    ):
10256        self.language = language
10257        if limits is not None:
10258            self.limits = _LimitsSettings(**limits)
10259        else:
10260            self.limits = None
10261        self.source = source
10262
10263
10264@dataclasses.dataclass
10265class _ProblemSettings_Cases_entry:
10266    """_ProblemSettings_Cases_entry"""
10267    Cases: Sequence['_ProblemSettings_Cases_entry_Cases_entry']
10268    Name: str
10269
10270    def __init__(
10271        self,
10272        *,
10273        Cases: Sequence[Dict[str, Any]],
10274        Name: str,
10275        # Ignore any unknown arguments
10276        **_kwargs: Any,
10277    ):
10278        self.Cases = [
10279            _ProblemSettings_Cases_entry_Cases_entry(**v) for v in Cases
10280        ]
10281        self.Name = Name
10282
10283
10284@dataclasses.dataclass
10285class _ProblemSettings_Cases_entry_Cases_entry:
10286    """_ProblemSettings_Cases_entry_Cases_entry"""
10287    Name: str
10288    Weight: float
10289
10290    def __init__(
10291        self,
10292        *,
10293        Name: str,
10294        Weight: float,
10295        # Ignore any unknown arguments
10296        **_kwargs: Any,
10297    ):
10298        self.Name = Name
10299        self.Weight = Weight
10300
10301
10302@dataclasses.dataclass
10303class _ProblemSettings_Interactive:
10304    """_ProblemSettings_Interactive"""
10305    Interfaces: Dict[str, Dict[str, '_InteractiveInterface']]
10306    LibinteractiveVersion: str
10307    Main: str
10308    ModuleName: str
10309    ParentLang: str
10310    Templates: Dict[str, str]
10311
10312    def __init__(
10313        self,
10314        *,
10315        Interfaces: Dict[str, Dict[str, Dict[str, Any]]],
10316        LibinteractiveVersion: str,
10317        Main: str,
10318        ModuleName: str,
10319        ParentLang: str,
10320        Templates: Dict[str, str],
10321        # Ignore any unknown arguments
10322        **_kwargs: Any,
10323    ):
10324        self.Interfaces = {
10325            k: {k: _InteractiveInterface(**v)
10326                for k, v in v.items()}
10327            for k, v in Interfaces.items()
10328        }
10329        self.LibinteractiveVersion = LibinteractiveVersion
10330        self.Main = Main
10331        self.ModuleName = ModuleName
10332        self.ParentLang = ParentLang
10333        self.Templates = {k: v for k, v in Templates.items()}
10334
10335
10336@dataclasses.dataclass
10337class _ProblemSettings_Validator:
10338    """_ProblemSettings_Validator"""
10339    GroupScorePolicy: Optional[str]
10340    Lang: Optional[str]
10341    Limits: Optional['_LimitsSettings']
10342    Name: str
10343    Tolerance: float
10344
10345    def __init__(
10346        self,
10347        *,
10348        Name: str,
10349        Tolerance: float,
10350        GroupScorePolicy: Optional[str] = None,
10351        Lang: Optional[str] = None,
10352        Limits: Optional[Dict[str, Any]] = None,
10353        # Ignore any unknown arguments
10354        **_kwargs: Any,
10355    ):
10356        if GroupScorePolicy is not None:
10357            self.GroupScorePolicy = GroupScorePolicy
10358        else:
10359            self.GroupScorePolicy = None
10360        if Lang is not None:
10361            self.Lang = Lang
10362        else:
10363            self.Lang = None
10364        if Limits is not None:
10365            self.Limits = _LimitsSettings(**Limits)
10366        else:
10367            self.Limits = None
10368        self.Name = Name
10369        self.Tolerance = Tolerance
10370
10371
10372@dataclasses.dataclass
10373class _ProblemStatement:
10374    """_ProblemStatement"""
10375    images: Dict[str, str]
10376    language: str
10377    markdown: str
10378    sources: Dict[str, str]
10379
10380    def __init__(
10381        self,
10382        *,
10383        images: Dict[str, str],
10384        language: str,
10385        markdown: str,
10386        sources: Dict[str, str],
10387        # Ignore any unknown arguments
10388        **_kwargs: Any,
10389    ):
10390        self.images = {k: v for k, v in images.items()}
10391        self.language = language
10392        self.markdown = markdown
10393        self.sources = {k: v for k, v in sources.items()}
10394
10395
10396@dataclasses.dataclass
10397class _ProblemVersion:
10398    """_ProblemVersion"""
10399    author: '_Signature'
10400    commit: str
10401    committer: '_Signature'
10402    message: str
10403    parents: Sequence[str]
10404    tree: Dict[str, str]
10405    version: str
10406
10407    def __init__(
10408        self,
10409        *,
10410        author: Dict[str, Any],
10411        commit: str,
10412        committer: Dict[str, Any],
10413        message: str,
10414        parents: Sequence[str],
10415        tree: Dict[str, str],
10416        version: str,
10417        # Ignore any unknown arguments
10418        **_kwargs: Any,
10419    ):
10420        self.author = _Signature(**author)
10421        self.commit = commit
10422        self.committer = _Signature(**committer)
10423        self.message = message
10424        self.parents = [v for v in parents]
10425        self.tree = {k: v for k, v in tree.items()}
10426        self.version = version
10427
10428
10429@dataclasses.dataclass
10430class _ProblemsMineInfoPayload:
10431    """_ProblemsMineInfoPayload"""
10432    isSysadmin: bool
10433    privateProblemsAlert: bool
10434    query: Optional[str]
10435    visibilityStatuses: Dict[str, int]
10436
10437    def __init__(
10438        self,
10439        *,
10440        isSysadmin: bool,
10441        privateProblemsAlert: bool,
10442        visibilityStatuses: Dict[str, int],
10443        query: Optional[str] = None,
10444        # Ignore any unknown arguments
10445        **_kwargs: Any,
10446    ):
10447        self.isSysadmin = isSysadmin
10448        self.privateProblemsAlert = privateProblemsAlert
10449        if query is not None:
10450            self.query = query
10451        else:
10452            self.query = None
10453        self.visibilityStatuses = {k: v for k, v in visibilityStatuses.items()}
10454
10455
10456@dataclasses.dataclass
10457class _Problemset:
10458    """_Problemset"""
10459    admin: Optional[bool]
10460    admission_mode: Optional[str]
10461    alias: Optional[str]
10462    archived: Optional[bool]
10463    assignment_type: Optional[str]
10464    contest_alias: Optional[str]
10465    courseAssignments: Optional[Sequence['_CourseAssignment']]
10466    description: Optional[str]
10467    director: Optional[str]
10468    feedback: Optional[str]
10469    finish_time: Optional[datetime.datetime]
10470    has_submissions: Optional[bool]
10471    languages: Optional[Sequence[str]]
10472    name: Optional[str]
10473    needs_basic_information: Optional[bool]
10474    opened: Optional[bool]
10475    original_contest_alias: Optional[str]
10476    original_problemset_id: Optional[int]
10477    partial_score: Optional[bool]
10478    penalty: Optional[int]
10479    penalty_calc_policy: Optional[str]
10480    penalty_type: Optional[str]
10481    points_decay_factor: Optional[float]
10482    problems: Optional[Sequence['_ProblemsetProblem']]
10483    problemset_id: Optional[int]
10484    requests_user_information: Optional[str]
10485    rerun_id: Optional[int]
10486    scoreboard: Optional[int]
10487    scoreboard_url: Optional[str]
10488    scoreboard_url_admin: Optional[str]
10489    show_penalty: Optional[bool]
10490    show_scoreboard_after: Optional[bool]
10491    start_time: Optional[datetime.datetime]
10492    submission_deadline: Optional[datetime.datetime]
10493    submissions_gap: Optional[int]
10494    title: Optional[str]
10495    users: Optional[Sequence['_Problemset_users_entry']]
10496    window_length: Optional[int]
10497
10498    def __init__(
10499        self,
10500        *,
10501        admin: Optional[bool] = None,
10502        admission_mode: Optional[str] = None,
10503        alias: Optional[str] = None,
10504        archived: Optional[bool] = None,
10505        assignment_type: Optional[str] = None,
10506        contest_alias: Optional[str] = None,
10507        courseAssignments: Optional[Sequence[Dict[str, Any]]] = None,
10508        description: Optional[str] = None,
10509        director: Optional[str] = None,
10510        feedback: Optional[str] = None,
10511        finish_time: Optional[int] = None,
10512        has_submissions: Optional[bool] = None,
10513        languages: Optional[Sequence[str]] = None,
10514        name: Optional[str] = None,
10515        needs_basic_information: Optional[bool] = None,
10516        opened: Optional[bool] = None,
10517        original_contest_alias: Optional[str] = None,
10518        original_problemset_id: Optional[int] = None,
10519        partial_score: Optional[bool] = None,
10520        penalty: Optional[int] = None,
10521        penalty_calc_policy: Optional[str] = None,
10522        penalty_type: Optional[str] = None,
10523        points_decay_factor: Optional[float] = None,
10524        problems: Optional[Sequence[Dict[str, Any]]] = None,
10525        problemset_id: Optional[int] = None,
10526        requests_user_information: Optional[str] = None,
10527        rerun_id: Optional[int] = None,
10528        scoreboard: Optional[int] = None,
10529        scoreboard_url: Optional[str] = None,
10530        scoreboard_url_admin: Optional[str] = None,
10531        show_penalty: Optional[bool] = None,
10532        show_scoreboard_after: Optional[bool] = None,
10533        start_time: Optional[int] = None,
10534        submission_deadline: Optional[int] = None,
10535        submissions_gap: Optional[int] = None,
10536        title: Optional[str] = None,
10537        users: Optional[Sequence[Dict[str, Any]]] = None,
10538        window_length: Optional[int] = None,
10539        # Ignore any unknown arguments
10540        **_kwargs: Any,
10541    ):
10542        if admin is not None:
10543            self.admin = admin
10544        else:
10545            self.admin = None
10546        if admission_mode is not None:
10547            self.admission_mode = admission_mode
10548        else:
10549            self.admission_mode = None
10550        if alias is not None:
10551            self.alias = alias
10552        else:
10553            self.alias = None
10554        if archived is not None:
10555            self.archived = archived
10556        else:
10557            self.archived = None
10558        if assignment_type is not None:
10559            self.assignment_type = assignment_type
10560        else:
10561            self.assignment_type = None
10562        if contest_alias is not None:
10563            self.contest_alias = contest_alias
10564        else:
10565            self.contest_alias = None
10566        if courseAssignments is not None:
10567            self.courseAssignments = [
10568                _CourseAssignment(**v) for v in courseAssignments
10569            ]
10570        else:
10571            self.courseAssignments = None
10572        if description is not None:
10573            self.description = description
10574        else:
10575            self.description = None
10576        if director is not None:
10577            self.director = director
10578        else:
10579            self.director = None
10580        if feedback is not None:
10581            self.feedback = feedback
10582        else:
10583            self.feedback = None
10584        if finish_time is not None:
10585            self.finish_time = datetime.datetime.fromtimestamp(finish_time)
10586        else:
10587            self.finish_time = None
10588        if has_submissions is not None:
10589            self.has_submissions = has_submissions
10590        else:
10591            self.has_submissions = None
10592        if languages is not None:
10593            self.languages = [v for v in languages]
10594        else:
10595            self.languages = None
10596        if name is not None:
10597            self.name = name
10598        else:
10599            self.name = None
10600        if needs_basic_information is not None:
10601            self.needs_basic_information = needs_basic_information
10602        else:
10603            self.needs_basic_information = None
10604        if opened is not None:
10605            self.opened = opened
10606        else:
10607            self.opened = None
10608        if original_contest_alias is not None:
10609            self.original_contest_alias = original_contest_alias
10610        else:
10611            self.original_contest_alias = None
10612        if original_problemset_id is not None:
10613            self.original_problemset_id = original_problemset_id
10614        else:
10615            self.original_problemset_id = None
10616        if partial_score is not None:
10617            self.partial_score = partial_score
10618        else:
10619            self.partial_score = None
10620        if penalty is not None:
10621            self.penalty = penalty
10622        else:
10623            self.penalty = None
10624        if penalty_calc_policy is not None:
10625            self.penalty_calc_policy = penalty_calc_policy
10626        else:
10627            self.penalty_calc_policy = None
10628        if penalty_type is not None:
10629            self.penalty_type = penalty_type
10630        else:
10631            self.penalty_type = None
10632        if points_decay_factor is not None:
10633            self.points_decay_factor = points_decay_factor
10634        else:
10635            self.points_decay_factor = None
10636        if problems is not None:
10637            self.problems = [_ProblemsetProblem(**v) for v in problems]
10638        else:
10639            self.problems = None
10640        if problemset_id is not None:
10641            self.problemset_id = problemset_id
10642        else:
10643            self.problemset_id = None
10644        if requests_user_information is not None:
10645            self.requests_user_information = requests_user_information
10646        else:
10647            self.requests_user_information = None
10648        if rerun_id is not None:
10649            self.rerun_id = rerun_id
10650        else:
10651            self.rerun_id = None
10652        if scoreboard is not None:
10653            self.scoreboard = scoreboard
10654        else:
10655            self.scoreboard = None
10656        if scoreboard_url is not None:
10657            self.scoreboard_url = scoreboard_url
10658        else:
10659            self.scoreboard_url = None
10660        if scoreboard_url_admin is not None:
10661            self.scoreboard_url_admin = scoreboard_url_admin
10662        else:
10663            self.scoreboard_url_admin = None
10664        if show_penalty is not None:
10665            self.show_penalty = show_penalty
10666        else:
10667            self.show_penalty = None
10668        if show_scoreboard_after is not None:
10669            self.show_scoreboard_after = show_scoreboard_after
10670        else:
10671            self.show_scoreboard_after = None
10672        if start_time is not None:
10673            self.start_time = datetime.datetime.fromtimestamp(start_time)
10674        else:
10675            self.start_time = None
10676        if submission_deadline is not None:
10677            self.submission_deadline = datetime.datetime.fromtimestamp(
10678                submission_deadline)
10679        else:
10680            self.submission_deadline = None
10681        if submissions_gap is not None:
10682            self.submissions_gap = submissions_gap
10683        else:
10684            self.submissions_gap = None
10685        if title is not None:
10686            self.title = title
10687        else:
10688            self.title = None
10689        if users is not None:
10690            self.users = [_Problemset_users_entry(**v) for v in users]
10691        else:
10692            self.users = None
10693        if window_length is not None:
10694            self.window_length = window_length
10695        else:
10696            self.window_length = None
10697
10698
10699@dataclasses.dataclass
10700class _ProblemsetProblem:
10701    """_ProblemsetProblem"""
10702    accepted: int
10703    accepts_submissions: bool
10704    alias: str
10705    commit: str
10706    difficulty: float
10707    has_submissions: bool
10708    input_limit: int
10709    is_extra_problem: bool
10710    languages: str
10711    letter: Optional[str]
10712    order: int
10713    points: float
10714    problem_id: Optional[int]
10715    quality_payload: Optional['_ProblemQualityPayload']
10716    quality_seal: bool
10717    submissions: int
10718    title: str
10719    version: str
10720    visibility: int
10721    visits: int
10722
10723    def __init__(
10724        self,
10725        *,
10726        accepted: int,
10727        accepts_submissions: bool,
10728        alias: str,
10729        commit: str,
10730        difficulty: float,
10731        has_submissions: bool,
10732        input_limit: int,
10733        is_extra_problem: bool,
10734        languages: str,
10735        order: int,
10736        points: float,
10737        quality_seal: bool,
10738        submissions: int,
10739        title: str,
10740        version: str,
10741        visibility: int,
10742        visits: int,
10743        letter: Optional[str] = None,
10744        problem_id: Optional[int] = None,
10745        quality_payload: Optional[Dict[str, Any]] = None,
10746        # Ignore any unknown arguments
10747        **_kwargs: Any,
10748    ):
10749        self.accepted = accepted
10750        self.accepts_submissions = accepts_submissions
10751        self.alias = alias
10752        self.commit = commit
10753        self.difficulty = difficulty
10754        self.has_submissions = has_submissions
10755        self.input_limit = input_limit
10756        self.is_extra_problem = is_extra_problem
10757        self.languages = languages
10758        if letter is not None:
10759            self.letter = letter
10760        else:
10761            self.letter = None
10762        self.order = order
10763        self.points = points
10764        if problem_id is not None:
10765            self.problem_id = problem_id
10766        else:
10767            self.problem_id = None
10768        if quality_payload is not None:
10769            self.quality_payload = _ProblemQualityPayload(**quality_payload)
10770        else:
10771            self.quality_payload = None
10772        self.quality_seal = quality_seal
10773        self.submissions = submissions
10774        self.title = title
10775        self.version = version
10776        self.visibility = visibility
10777        self.visits = visits
10778
10779
10780@dataclasses.dataclass
10781class _ProblemsetProblemWithVersions:
10782    """_ProblemsetProblemWithVersions"""
10783    accepted: int
10784    accepts_submissions: bool
10785    alias: str
10786    commit: str
10787    difficulty: float
10788    has_submissions: bool
10789    input_limit: int
10790    languages: str
10791    letter: Optional[str]
10792    order: int
10793    points: float
10794    quality_payload: Optional['_ProblemQualityPayload']
10795    quality_seal: bool
10796    submissions: int
10797    title: str
10798    version: str
10799    versions: '_ProblemsetProblemWithVersions_versions'
10800    visibility: int
10801    visits: int
10802
10803    def __init__(
10804        self,
10805        *,
10806        accepted: int,
10807        accepts_submissions: bool,
10808        alias: str,
10809        commit: str,
10810        difficulty: float,
10811        has_submissions: bool,
10812        input_limit: int,
10813        languages: str,
10814        order: int,
10815        points: float,
10816        quality_seal: bool,
10817        submissions: int,
10818        title: str,
10819        version: str,
10820        versions: Dict[str, Any],
10821        visibility: int,
10822        visits: int,
10823        letter: Optional[str] = None,
10824        quality_payload: Optional[Dict[str, Any]] = None,
10825        # Ignore any unknown arguments
10826        **_kwargs: Any,
10827    ):
10828        self.accepted = accepted
10829        self.accepts_submissions = accepts_submissions
10830        self.alias = alias
10831        self.commit = commit
10832        self.difficulty = difficulty
10833        self.has_submissions = has_submissions
10834        self.input_limit = input_limit
10835        self.languages = languages
10836        if letter is not None:
10837            self.letter = letter
10838        else:
10839            self.letter = None
10840        self.order = order
10841        self.points = points
10842        if quality_payload is not None:
10843            self.quality_payload = _ProblemQualityPayload(**quality_payload)
10844        else:
10845            self.quality_payload = None
10846        self.quality_seal = quality_seal
10847        self.submissions = submissions
10848        self.title = title
10849        self.version = version
10850        self.versions = _ProblemsetProblemWithVersions_versions(**versions)
10851        self.visibility = visibility
10852        self.visits = visits
10853
10854
10855@dataclasses.dataclass
10856class _ProblemsetProblemWithVersions_versions:
10857    """_ProblemsetProblemWithVersions_versions"""
10858    log: Sequence['_ProblemVersion']
10859    published: str
10860
10861    def __init__(
10862        self,
10863        *,
10864        log: Sequence[Dict[str, Any]],
10865        published: str,
10866        # Ignore any unknown arguments
10867        **_kwargs: Any,
10868    ):
10869        self.log = [_ProblemVersion(**v) for v in log]
10870        self.published = published
10871
10872
10873@dataclasses.dataclass
10874class _Problemset_users_entry:
10875    """_Problemset_users_entry"""
10876    access_time: Optional[datetime.datetime]
10877    country: Optional[str]
10878    email: Optional[str]
10879    user_id: Optional[int]
10880    username: str
10881
10882    def __init__(
10883        self,
10884        *,
10885        username: str,
10886        access_time: Optional[int] = None,
10887        country: Optional[str] = None,
10888        email: Optional[str] = None,
10889        user_id: Optional[int] = None,
10890        # Ignore any unknown arguments
10891        **_kwargs: Any,
10892    ):
10893        if access_time is not None:
10894            self.access_time = datetime.datetime.fromtimestamp(access_time)
10895        else:
10896            self.access_time = None
10897        if country is not None:
10898            self.country = country
10899        else:
10900            self.country = None
10901        if email is not None:
10902            self.email = email
10903        else:
10904            self.email = None
10905        if user_id is not None:
10906            self.user_id = user_id
10907        else:
10908            self.user_id = None
10909        self.username = username
10910
10911
10912@dataclasses.dataclass
10913class _ProblemsetterInfo:
10914    """_ProblemsetterInfo"""
10915    classname: str
10916    creation_date: Optional[datetime.datetime]
10917    name: str
10918    username: str
10919
10920    def __init__(
10921        self,
10922        *,
10923        classname: str,
10924        name: str,
10925        username: str,
10926        creation_date: Optional[int] = None,
10927        # Ignore any unknown arguments
10928        **_kwargs: Any,
10929    ):
10930        self.classname = classname
10931        if creation_date is not None:
10932            self.creation_date = datetime.datetime.fromtimestamp(creation_date)
10933        else:
10934            self.creation_date = None
10935        self.name = name
10936        self.username = username
10937
10938
10939@dataclasses.dataclass
10940class _Progress:
10941    """_Progress"""
10942    max_score: float
10943    score: float
10944
10945    def __init__(
10946        self,
10947        *,
10948        max_score: float,
10949        score: float,
10950        # Ignore any unknown arguments
10951        **_kwargs: Any,
10952    ):
10953        self.max_score = max_score
10954        self.score = score
10955
10956
10957@dataclasses.dataclass
10958class _Run:
10959    """_Run"""
10960    alias: str
10961    classname: str
10962    contest_alias: Optional[str]
10963    contest_score: Optional[float]
10964    country: str
10965    guid: str
10966    language: str
10967    memory: int
10968    penalty: int
10969    runtime: int
10970    score: float
10971    status: str
10972    submit_delay: int
10973    time: datetime.datetime
10974    type: Optional[str]
10975    username: str
10976    verdict: str
10977
10978    def __init__(
10979        self,
10980        *,
10981        alias: str,
10982        classname: str,
10983        country: str,
10984        guid: str,
10985        language: str,
10986        memory: int,
10987        penalty: int,
10988        runtime: int,
10989        score: float,
10990        status: str,
10991        submit_delay: int,
10992        time: int,
10993        username: str,
10994        verdict: str,
10995        contest_alias: Optional[str] = None,
10996        contest_score: Optional[float] = None,
10997        type: Optional[str] = None,
10998        # Ignore any unknown arguments
10999        **_kwargs: Any,
11000    ):
11001        self.alias = alias
11002        self.classname = classname
11003        if contest_alias is not None:
11004            self.contest_alias = contest_alias
11005        else:
11006            self.contest_alias = None
11007        if contest_score is not None:
11008            self.contest_score = contest_score
11009        else:
11010            self.contest_score = None
11011        self.country = country
11012        self.guid = guid
11013        self.language = language
11014        self.memory = memory
11015        self.penalty = penalty
11016        self.runtime = runtime
11017        self.score = score
11018        self.status = status
11019        self.submit_delay = submit_delay
11020        self.time = datetime.datetime.fromtimestamp(time)
11021        if type is not None:
11022            self.type = type
11023        else:
11024            self.type = None
11025        self.username = username
11026        self.verdict = verdict
11027
11028
11029@dataclasses.dataclass
11030class _RunDetails:
11031    """_RunDetails"""
11032    admin: bool
11033    alias: str
11034    cases: Dict[str, '_ProblemCasesContents_value']
11035    compile_error: Optional[str]
11036    details: Optional['_RunDetails_details']
11037    feedback: Optional['_SubmissionFeedback']
11038    guid: str
11039    judged_by: Optional[str]
11040    language: str
11041    logs: Optional[str]
11042    show_diff: str
11043    source: Optional[str]
11044    source_link: Optional[bool]
11045    source_name: Optional[str]
11046    source_url: Optional[str]
11047
11048    def __init__(
11049        self,
11050        *,
11051        admin: bool,
11052        alias: str,
11053        cases: Dict[str, Dict[str, Any]],
11054        guid: str,
11055        language: str,
11056        show_diff: str,
11057        compile_error: Optional[str] = None,
11058        details: Optional[Dict[str, Any]] = None,
11059        feedback: Optional[Dict[str, Any]] = None,
11060        judged_by: Optional[str] = None,
11061        logs: Optional[str] = None,
11062        source: Optional[str] = None,
11063        source_link: Optional[bool] = None,
11064        source_name: Optional[str] = None,
11065        source_url: Optional[str] = None,
11066        # Ignore any unknown arguments
11067        **_kwargs: Any,
11068    ):
11069        self.admin = admin
11070        self.alias = alias
11071        self.cases = {
11072            k: _ProblemCasesContents_value(**v)
11073            for k, v in cases.items()
11074        }
11075        if compile_error is not None:
11076            self.compile_error = compile_error
11077        else:
11078            self.compile_error = None
11079        if details is not None:
11080            self.details = _RunDetails_details(**details)
11081        else:
11082            self.details = None
11083        if feedback is not None:
11084            self.feedback = _SubmissionFeedback(**feedback)
11085        else:
11086            self.feedback = None
11087        self.guid = guid
11088        if judged_by is not None:
11089            self.judged_by = judged_by
11090        else:
11091            self.judged_by = None
11092        self.language = language
11093        if logs is not None:
11094            self.logs = logs
11095        else:
11096            self.logs = None
11097        self.show_diff = show_diff
11098        if source is not None:
11099            self.source = source
11100        else:
11101            self.source = None
11102        if source_link is not None:
11103            self.source_link = source_link
11104        else:
11105            self.source_link = None
11106        if source_name is not None:
11107            self.source_name = source_name
11108        else:
11109            self.source_name = None
11110        if source_url is not None:
11111            self.source_url = source_url
11112        else:
11113            self.source_url = None
11114
11115
11116@dataclasses.dataclass
11117class _RunDetailsGroup:
11118    """_RunDetailsGroup"""
11119    cases: Sequence['_CaseResult']
11120    contest_score: float
11121    group: str
11122    max_score: float
11123    score: float
11124    verdict: Optional[str]
11125
11126    def __init__(
11127        self,
11128        *,
11129        cases: Sequence[Dict[str, Any]],
11130        contest_score: float,
11131        group: str,
11132        max_score: float,
11133        score: float,
11134        verdict: Optional[str] = None,
11135        # Ignore any unknown arguments
11136        **_kwargs: Any,
11137    ):
11138        self.cases = [_CaseResult(**v) for v in cases]
11139        self.contest_score = contest_score
11140        self.group = group
11141        self.max_score = max_score
11142        self.score = score
11143        if verdict is not None:
11144            self.verdict = verdict
11145        else:
11146            self.verdict = None
11147
11148
11149@dataclasses.dataclass
11150class _RunDetailsV2:
11151    """_RunDetailsV2"""
11152    admin: bool
11153    cases: Dict[str, '_ProblemCasesContents_value']
11154    compile_error: Optional[str]
11155    details: Optional['_RunDetailsV2_details']
11156    feedback: Optional['_SubmissionFeedback']
11157    judged_by: Optional[str]
11158    logs: Optional[str]
11159    show_diff: str
11160    source: Optional[str]
11161    source_link: Optional[bool]
11162    source_name: Optional[str]
11163    source_url: Optional[str]
11164
11165    def __init__(
11166        self,
11167        *,
11168        admin: bool,
11169        cases: Dict[str, Dict[str, Any]],
11170        show_diff: str,
11171        compile_error: Optional[str] = None,
11172        details: Optional[Dict[str, Any]] = None,
11173        feedback: Optional[Dict[str, Any]] = None,
11174        judged_by: Optional[str] = None,
11175        logs: Optional[str] = None,
11176        source: Optional[str] = None,
11177        source_link: Optional[bool] = None,
11178        source_name: Optional[str] = None,
11179        source_url: Optional[str] = None,
11180        # Ignore any unknown arguments
11181        **_kwargs: Any,
11182    ):
11183        self.admin = admin
11184        self.cases = {
11185            k: _ProblemCasesContents_value(**v)
11186            for k, v in cases.items()
11187        }
11188        if compile_error is not None:
11189            self.compile_error = compile_error
11190        else:
11191            self.compile_error = None
11192        if details is not None:
11193            self.details = _RunDetailsV2_details(**details)
11194        else:
11195            self.details = None
11196        if feedback is not None:
11197            self.feedback = _SubmissionFeedback(**feedback)
11198        else:
11199            self.feedback = None
11200        if judged_by is not None:
11201            self.judged_by = judged_by
11202        else:
11203            self.judged_by = None
11204        if logs is not None:
11205            self.logs = logs
11206        else:
11207            self.logs = None
11208        self.show_diff = show_diff
11209        if source is not None:
11210            self.source = source
11211        else:
11212            self.source = None
11213        if source_link is not None:
11214            self.source_link = source_link
11215        else:
11216            self.source_link = None
11217        if source_name is not None:
11218            self.source_name = source_name
11219        else:
11220            self.source_name = None
11221        if source_url is not None:
11222            self.source_url = source_url
11223        else:
11224            self.source_url = None
11225
11226
11227@dataclasses.dataclass
11228class _RunDetailsV2_details:
11229    """_RunDetailsV2_details"""
11230    compile_meta: Optional[Dict[str, '_RunMetadata']]
11231    groups: Optional[Sequence['_RunDetailsGroup']]
11232    judged_by: str
11233    max_score: Optional[float]
11234    memory: Optional[float]
11235    score: float
11236    time: Optional[float]
11237    verdict: str
11238    wall_time: Optional[float]
11239
11240    def __init__(
11241        self,
11242        *,
11243        judged_by: str,
11244        score: float,
11245        verdict: str,
11246        compile_meta: Optional[Dict[str, Dict[str, Any]]] = None,
11247        groups: Optional[Sequence[Dict[str, Any]]] = None,
11248        max_score: Optional[float] = None,
11249        memory: Optional[float] = None,
11250        time: Optional[float] = None,
11251        wall_time: Optional[float] = None,
11252        # Ignore any unknown arguments
11253        **_kwargs: Any,
11254    ):
11255        if compile_meta is not None:
11256            self.compile_meta = {
11257                k: _RunMetadata(**v)
11258                for k, v in compile_meta.items()
11259            }
11260        else:
11261            self.compile_meta = None
11262        if groups is not None:
11263            self.groups = [_RunDetailsGroup(**v) for v in groups]
11264        else:
11265            self.groups = None
11266        self.judged_by = judged_by
11267        if max_score is not None:
11268            self.max_score = max_score
11269        else:
11270            self.max_score = None
11271        if memory is not None:
11272            self.memory = memory
11273        else:
11274            self.memory = None
11275        self.score = score
11276        if time is not None:
11277            self.time = time
11278        else:
11279            self.time = None
11280        self.verdict = verdict
11281        if wall_time is not None:
11282            self.wall_time = wall_time
11283        else:
11284            self.wall_time = None
11285
11286
11287@dataclasses.dataclass
11288class _RunDetails_details:
11289    """_RunDetails_details"""
11290    compile_meta: Optional[Dict[str, '_RunMetadata']]
11291    contest_score: float
11292    groups: Optional[Sequence['_RunDetailsGroup']]
11293    judged_by: str
11294    max_score: Optional[float]
11295    memory: Optional[float]
11296    score: float
11297    time: Optional[float]
11298    verdict: str
11299    wall_time: Optional[float]
11300
11301    def __init__(
11302        self,
11303        *,
11304        contest_score: float,
11305        judged_by: str,
11306        score: float,
11307        verdict: str,
11308        compile_meta: Optional[Dict[str, Dict[str, Any]]] = None,
11309        groups: Optional[Sequence[Dict[str, Any]]] = None,
11310        max_score: Optional[float] = None,
11311        memory: Optional[float] = None,
11312        time: Optional[float] = None,
11313        wall_time: Optional[float] = None,
11314        # Ignore any unknown arguments
11315        **_kwargs: Any,
11316    ):
11317        if compile_meta is not None:
11318            self.compile_meta = {
11319                k: _RunMetadata(**v)
11320                for k, v in compile_meta.items()
11321            }
11322        else:
11323            self.compile_meta = None
11324        self.contest_score = contest_score
11325        if groups is not None:
11326            self.groups = [_RunDetailsGroup(**v) for v in groups]
11327        else:
11328            self.groups = None
11329        self.judged_by = judged_by
11330        if max_score is not None:
11331            self.max_score = max_score
11332        else:
11333            self.max_score = None
11334        if memory is not None:
11335            self.memory = memory
11336        else:
11337            self.memory = None
11338        self.score = score
11339        if time is not None:
11340            self.time = time
11341        else:
11342            self.time = None
11343        self.verdict = verdict
11344        if wall_time is not None:
11345            self.wall_time = wall_time
11346        else:
11347            self.wall_time = None
11348
11349
11350@dataclasses.dataclass
11351class _RunMetadata:
11352    """_RunMetadata"""
11353    memory: int
11354    sys_time: int
11355    time: float
11356    verdict: str
11357    wall_time: float
11358
11359    def __init__(
11360        self,
11361        *,
11362        memory: int,
11363        sys_time: int,
11364        time: float,
11365        verdict: str,
11366        wall_time: float,
11367        # Ignore any unknown arguments
11368        **_kwargs: Any,
11369    ):
11370        self.memory = memory
11371        self.sys_time = sys_time
11372        self.time = time
11373        self.verdict = verdict
11374        self.wall_time = wall_time
11375
11376
11377@dataclasses.dataclass
11378class _RunWithDetails:
11379    """_RunWithDetails"""
11380    alias: str
11381    classname: str
11382    contest_alias: Optional[str]
11383    contest_score: Optional[float]
11384    country: str
11385    details: Optional['_RunDetailsV2']
11386    guid: str
11387    language: str
11388    memory: int
11389    penalty: int
11390    runtime: int
11391    score: float
11392    status: str
11393    submit_delay: int
11394    time: datetime.datetime
11395    type: Optional[str]
11396    username: str
11397    verdict: str
11398
11399    def __init__(
11400        self,
11401        *,
11402        alias: str,
11403        classname: str,
11404        country: str,
11405        guid: str,
11406        language: str,
11407        memory: int,
11408        penalty: int,
11409        runtime: int,
11410        score: float,
11411        status: str,
11412        submit_delay: int,
11413        time: int,
11414        username: str,
11415        verdict: str,
11416        contest_alias: Optional[str] = None,
11417        contest_score: Optional[float] = None,
11418        details: Optional[Dict[str, Any]] = None,
11419        type: Optional[str] = None,
11420        # Ignore any unknown arguments
11421        **_kwargs: Any,
11422    ):
11423        self.alias = alias
11424        self.classname = classname
11425        if contest_alias is not None:
11426            self.contest_alias = contest_alias
11427        else:
11428            self.contest_alias = None
11429        if contest_score is not None:
11430            self.contest_score = contest_score
11431        else:
11432            self.contest_score = None
11433        self.country = country
11434        if details is not None:
11435            self.details = _RunDetailsV2(**details)
11436        else:
11437            self.details = None
11438        self.guid = guid
11439        self.language = language
11440        self.memory = memory
11441        self.penalty = penalty
11442        self.runtime = runtime
11443        self.score = score
11444        self.status = status
11445        self.submit_delay = submit_delay
11446        self.time = datetime.datetime.fromtimestamp(time)
11447        if type is not None:
11448            self.type = type
11449        else:
11450            self.type = None
11451        self.username = username
11452        self.verdict = verdict
11453
11454
11455@dataclasses.dataclass
11456class _RunsDiff:
11457    """_RunsDiff"""
11458    guid: str
11459    new_score: Optional[float]
11460    new_status: Optional[str]
11461    new_verdict: Optional[str]
11462    old_score: Optional[float]
11463    old_status: Optional[str]
11464    old_verdict: Optional[str]
11465    problemset_id: Optional[int]
11466    username: str
11467
11468    def __init__(
11469        self,
11470        *,
11471        guid: str,
11472        username: str,
11473        new_score: Optional[float] = None,
11474        new_status: Optional[str] = None,
11475        new_verdict: Optional[str] = None,
11476        old_score: Optional[float] = None,
11477        old_status: Optional[str] = None,
11478        old_verdict: Optional[str] = None,
11479        problemset_id: Optional[int] = None,
11480        # Ignore any unknown arguments
11481        **_kwargs: Any,
11482    ):
11483        self.guid = guid
11484        if new_score is not None:
11485            self.new_score = new_score
11486        else:
11487            self.new_score = None
11488        if new_status is not None:
11489            self.new_status = new_status
11490        else:
11491            self.new_status = None
11492        if new_verdict is not None:
11493            self.new_verdict = new_verdict
11494        else:
11495            self.new_verdict = None
11496        if old_score is not None:
11497            self.old_score = old_score
11498        else:
11499            self.old_score = None
11500        if old_status is not None:
11501            self.old_status = old_status
11502        else:
11503            self.old_status = None
11504        if old_verdict is not None:
11505            self.old_verdict = old_verdict
11506        else:
11507            self.old_verdict = None
11508        if problemset_id is not None:
11509            self.problemset_id = problemset_id
11510        else:
11511            self.problemset_id = None
11512        self.username = username
11513
11514
11515@dataclasses.dataclass
11516class _School:
11517    """_School"""
11518    country_id: Optional[str]
11519    name: str
11520    ranking: Optional[int]
11521    school_id: int
11522    score: float
11523
11524    def __init__(
11525        self,
11526        *,
11527        name: str,
11528        school_id: int,
11529        score: float,
11530        country_id: Optional[str] = None,
11531        ranking: Optional[int] = None,
11532        # Ignore any unknown arguments
11533        **_kwargs: Any,
11534    ):
11535        if country_id is not None:
11536            self.country_id = country_id
11537        else:
11538            self.country_id = None
11539        self.name = name
11540        if ranking is not None:
11541            self.ranking = ranking
11542        else:
11543            self.ranking = None
11544        self.school_id = school_id
11545        self.score = score
11546
11547
11548@dataclasses.dataclass
11549class _SchoolCoderOfTheMonth:
11550    """_SchoolCoderOfTheMonth"""
11551    classname: str
11552    time: str
11553    username: str
11554
11555    def __init__(
11556        self,
11557        *,
11558        classname: str,
11559        time: str,
11560        username: str,
11561        # Ignore any unknown arguments
11562        **_kwargs: Any,
11563    ):
11564        self.classname = classname
11565        self.time = time
11566        self.username = username
11567
11568
11569@dataclasses.dataclass
11570class _SchoolListItem:
11571    """_SchoolListItem"""
11572    key: int
11573    value: str
11574
11575    def __init__(
11576        self,
11577        *,
11578        key: int,
11579        value: str,
11580        # Ignore any unknown arguments
11581        **_kwargs: Any,
11582    ):
11583        self.key = key
11584        self.value = value
11585
11586
11587@dataclasses.dataclass
11588class _SchoolOfTheMonthPayload:
11589    """_SchoolOfTheMonthPayload"""
11590    candidatesToSchoolOfTheMonth: Sequence[
11591        '_SchoolOfTheMonthPayload_candidatesToSchoolOfTheMonth_entry']
11592    isMentor: bool
11593    options: Optional['_SchoolOfTheMonthPayload_options']
11594    schoolsOfPreviousMonth: Sequence[
11595        '_SchoolOfTheMonthPayload_schoolsOfPreviousMonth_entry']
11596    schoolsOfPreviousMonths: Sequence[
11597        '_SchoolOfTheMonthPayload_schoolsOfPreviousMonths_entry']
11598
11599    def __init__(
11600        self,
11601        *,
11602        candidatesToSchoolOfTheMonth: Sequence[Dict[str, Any]],
11603        isMentor: bool,
11604        schoolsOfPreviousMonth: Sequence[Dict[str, Any]],
11605        schoolsOfPreviousMonths: Sequence[Dict[str, Any]],
11606        options: Optional[Dict[str, Any]] = None,
11607        # Ignore any unknown arguments
11608        **_kwargs: Any,
11609    ):
11610        self.candidatesToSchoolOfTheMonth = [
11611            _SchoolOfTheMonthPayload_candidatesToSchoolOfTheMonth_entry(**v)
11612            for v in candidatesToSchoolOfTheMonth
11613        ]
11614        self.isMentor = isMentor
11615        if options is not None:
11616            self.options = _SchoolOfTheMonthPayload_options(**options)
11617        else:
11618            self.options = None
11619        self.schoolsOfPreviousMonth = [
11620            _SchoolOfTheMonthPayload_schoolsOfPreviousMonth_entry(**v)
11621            for v in schoolsOfPreviousMonth
11622        ]
11623        self.schoolsOfPreviousMonths = [
11624            _SchoolOfTheMonthPayload_schoolsOfPreviousMonths_entry(**v)
11625            for v in schoolsOfPreviousMonths
11626        ]
11627
11628
11629@dataclasses.dataclass
11630class _SchoolOfTheMonthPayload_candidatesToSchoolOfTheMonth_entry:
11631    """_SchoolOfTheMonthPayload_candidatesToSchoolOfTheMonth_entry"""
11632    country_id: str
11633    name: str
11634    ranking: int
11635    school_id: int
11636    school_of_the_month_id: int
11637    score: float
11638
11639    def __init__(
11640        self,
11641        *,
11642        country_id: str,
11643        name: str,
11644        ranking: int,
11645        school_id: int,
11646        school_of_the_month_id: int,
11647        score: float,
11648        # Ignore any unknown arguments
11649        **_kwargs: Any,
11650    ):
11651        self.country_id = country_id
11652        self.name = name
11653        self.ranking = ranking
11654        self.school_id = school_id
11655        self.school_of_the_month_id = school_of_the_month_id
11656        self.score = score
11657
11658
11659@dataclasses.dataclass
11660class _SchoolOfTheMonthPayload_options:
11661    """_SchoolOfTheMonthPayload_options"""
11662    canChooseSchool: bool
11663    schoolIsSelected: bool
11664
11665    def __init__(
11666        self,
11667        *,
11668        canChooseSchool: bool,
11669        schoolIsSelected: bool,
11670        # Ignore any unknown arguments
11671        **_kwargs: Any,
11672    ):
11673        self.canChooseSchool = canChooseSchool
11674        self.schoolIsSelected = schoolIsSelected
11675
11676
11677@dataclasses.dataclass
11678class _SchoolOfTheMonthPayload_schoolsOfPreviousMonth_entry:
11679    """_SchoolOfTheMonthPayload_schoolsOfPreviousMonth_entry"""
11680    country_id: str
11681    name: str
11682    ranking: int
11683    school_id: int
11684
11685    def __init__(
11686        self,
11687        *,
11688        country_id: str,
11689        name: str,
11690        ranking: int,
11691        school_id: int,
11692        # Ignore any unknown arguments
11693        **_kwargs: Any,
11694    ):
11695        self.country_id = country_id
11696        self.name = name
11697        self.ranking = ranking
11698        self.school_id = school_id
11699
11700
11701@dataclasses.dataclass
11702class _SchoolOfTheMonthPayload_schoolsOfPreviousMonths_entry:
11703    """_SchoolOfTheMonthPayload_schoolsOfPreviousMonths_entry"""
11704    country_id: str
11705    name: str
11706    school_id: int
11707    time: str
11708
11709    def __init__(
11710        self,
11711        *,
11712        country_id: str,
11713        name: str,
11714        school_id: int,
11715        time: str,
11716        # Ignore any unknown arguments
11717        **_kwargs: Any,
11718    ):
11719        self.country_id = country_id
11720        self.name = name
11721        self.school_id = school_id
11722        self.time = time
11723
11724
11725@dataclasses.dataclass
11726class _SchoolProblemsSolved:
11727    """_SchoolProblemsSolved"""
11728    month: int
11729    problems_solved: int
11730    year: int
11731
11732    def __init__(
11733        self,
11734        *,
11735        month: int,
11736        problems_solved: int,
11737        year: int,
11738        # Ignore any unknown arguments
11739        **_kwargs: Any,
11740    ):
11741        self.month = month
11742        self.problems_solved = problems_solved
11743        self.year = year
11744
11745
11746@dataclasses.dataclass
11747class _SchoolProfileDetailsPayload:
11748    """_SchoolProfileDetailsPayload"""
11749    coders_of_the_month: Sequence['_SchoolCoderOfTheMonth']
11750    country: Optional['_SchoolProfileDetailsPayload_country']
11751    monthly_solved_problems: Sequence['_SchoolProblemsSolved']
11752    ranking: int
11753    school_id: int
11754    school_name: str
11755    school_users: Sequence['_SchoolUser']
11756    state_name: Optional[str]
11757
11758    def __init__(
11759        self,
11760        *,
11761        coders_of_the_month: Sequence[Dict[str, Any]],
11762        monthly_solved_problems: Sequence[Dict[str, Any]],
11763        ranking: int,
11764        school_id: int,
11765        school_name: str,
11766        school_users: Sequence[Dict[str, Any]],
11767        country: Optional[Dict[str, Any]] = None,
11768        state_name: Optional[str] = None,
11769        # Ignore any unknown arguments
11770        **_kwargs: Any,
11771    ):
11772        self.coders_of_the_month = [
11773            _SchoolCoderOfTheMonth(**v) for v in coders_of_the_month
11774        ]
11775        if country is not None:
11776            self.country = _SchoolProfileDetailsPayload_country(**country)
11777        else:
11778            self.country = None
11779        self.monthly_solved_problems = [
11780            _SchoolProblemsSolved(**v) for v in monthly_solved_problems
11781        ]
11782        self.ranking = ranking
11783        self.school_id = school_id
11784        self.school_name = school_name
11785        self.school_users = [_SchoolUser(**v) for v in school_users]
11786        if state_name is not None:
11787            self.state_name = state_name
11788        else:
11789            self.state_name = None
11790
11791
11792@dataclasses.dataclass
11793class _SchoolProfileDetailsPayload_country:
11794    """_SchoolProfileDetailsPayload_country"""
11795    id: str
11796    name: str
11797
11798    def __init__(
11799        self,
11800        *,
11801        id: str,
11802        name: str,
11803        # Ignore any unknown arguments
11804        **_kwargs: Any,
11805    ):
11806        self.id = id
11807        self.name = name
11808
11809
11810@dataclasses.dataclass
11811class _SchoolRankPayload:
11812    """_SchoolRankPayload"""
11813    length: int
11814    page: int
11815    pagerItems: Sequence['_PageItem']
11816    rank: Sequence['_School']
11817    showHeader: bool
11818    totalRows: int
11819
11820    def __init__(
11821        self,
11822        *,
11823        length: int,
11824        page: int,
11825        pagerItems: Sequence[Dict[str, Any]],
11826        rank: Sequence[Dict[str, Any]],
11827        showHeader: bool,
11828        totalRows: int,
11829        # Ignore any unknown arguments
11830        **_kwargs: Any,
11831    ):
11832        self.length = length
11833        self.page = page
11834        self.pagerItems = [_PageItem(**v) for v in pagerItems]
11835        self.rank = [_School(**v) for v in rank]
11836        self.showHeader = showHeader
11837        self.totalRows = totalRows
11838
11839
11840@dataclasses.dataclass
11841class _SchoolUser:
11842    """_SchoolUser"""
11843    classname: str
11844    created_problems: int
11845    organized_contests: int
11846    solved_problems: int
11847    username: str
11848
11849    def __init__(
11850        self,
11851        *,
11852        classname: str,
11853        created_problems: int,
11854        organized_contests: int,
11855        solved_problems: int,
11856        username: str,
11857        # Ignore any unknown arguments
11858        **_kwargs: Any,
11859    ):
11860        self.classname = classname
11861        self.created_problems = created_problems
11862        self.organized_contests = organized_contests
11863        self.solved_problems = solved_problems
11864        self.username = username
11865
11866
11867@dataclasses.dataclass
11868class _Scoreboard:
11869    """_Scoreboard"""
11870    finish_time: Optional[datetime.datetime]
11871    problems: Sequence['_Scoreboard_problems_entry']
11872    ranking: Sequence['_ScoreboardRankingEntry']
11873    start_time: datetime.datetime
11874    time: datetime.datetime
11875    title: str
11876
11877    def __init__(
11878        self,
11879        *,
11880        problems: Sequence[Dict[str, Any]],
11881        ranking: Sequence[Dict[str, Any]],
11882        start_time: int,
11883        time: int,
11884        title: str,
11885        finish_time: Optional[int] = None,
11886        # Ignore any unknown arguments
11887        **_kwargs: Any,
11888    ):
11889        if finish_time is not None:
11890            self.finish_time = datetime.datetime.fromtimestamp(finish_time)
11891        else:
11892            self.finish_time = None
11893        self.problems = [_Scoreboard_problems_entry(**v) for v in problems]
11894        self.ranking = [_ScoreboardRankingEntry(**v) for v in ranking]
11895        self.start_time = datetime.datetime.fromtimestamp(start_time)
11896        self.time = datetime.datetime.fromtimestamp(time)
11897        self.title = title
11898
11899
11900@dataclasses.dataclass
11901class _ScoreboardContest:
11902    """_ScoreboardContest"""
11903    acl_id: int
11904    admission_mode: str
11905    alias: str
11906    contest_id: int
11907    description: str
11908    feedback: str
11909    finish_time: datetime.datetime
11910    languages: str
11911    last_updated: int
11912    only_ac: Optional[bool]
11913    partial_score: bool
11914    penalty: str
11915    penalty_calc_policy: str
11916    points_decay_factor: float
11917    problemset_id: int
11918    recommended: bool
11919    rerun_id: int
11920    scoreboard: int
11921    show_scoreboard_after: bool
11922    start_time: datetime.datetime
11923    submissions_gap: int
11924    title: str
11925    urgent: bool
11926    weight: Optional[float]
11927    window_length: Optional[int]
11928
11929    def __init__(
11930        self,
11931        *,
11932        acl_id: int,
11933        admission_mode: str,
11934        alias: str,
11935        contest_id: int,
11936        description: str,
11937        feedback: str,
11938        finish_time: int,
11939        languages: str,
11940        last_updated: int,
11941        partial_score: bool,
11942        penalty: str,
11943        penalty_calc_policy: str,
11944        points_decay_factor: float,
11945        problemset_id: int,
11946        recommended: bool,
11947        rerun_id: int,
11948        scoreboard: int,
11949        show_scoreboard_after: bool,
11950        start_time: int,
11951        submissions_gap: int,
11952        title: str,
11953        urgent: bool,
11954        only_ac: Optional[bool] = None,
11955        weight: Optional[float] = None,
11956        window_length: Optional[int] = None,
11957        # Ignore any unknown arguments
11958        **_kwargs: Any,
11959    ):
11960        self.acl_id = acl_id
11961        self.admission_mode = admission_mode
11962        self.alias = alias
11963        self.contest_id = contest_id
11964        self.description = description
11965        self.feedback = feedback
11966        self.finish_time = datetime.datetime.fromtimestamp(finish_time)
11967        self.languages = languages
11968        self.last_updated = last_updated
11969        if only_ac is not None:
11970            self.only_ac = only_ac
11971        else:
11972            self.only_ac = None
11973        self.partial_score = partial_score
11974        self.penalty = penalty
11975        self.penalty_calc_policy = penalty_calc_policy
11976        self.points_decay_factor = points_decay_factor
11977        self.problemset_id = problemset_id
11978        self.recommended = recommended
11979        self.rerun_id = rerun_id
11980        self.scoreboard = scoreboard
11981        self.show_scoreboard_after = show_scoreboard_after
11982        self.start_time = datetime.datetime.fromtimestamp(start_time)
11983        self.submissions_gap = submissions_gap
11984        self.title = title
11985        self.urgent = urgent
11986        if weight is not None:
11987            self.weight = weight
11988        else:
11989            self.weight = None
11990        if window_length is not None:
11991            self.window_length = window_length
11992        else:
11993            self.window_length = None
11994
11995
11996@dataclasses.dataclass
11997class _ScoreboardDetails:
11998    """_ScoreboardDetails"""
11999    alias: str
12000    create_time: int
12001    description: str
12002    group_id: int
12003    group_scoreboard_id: int
12004    name: str
12005
12006    def __init__(
12007        self,
12008        *,
12009        alias: str,
12010        create_time: int,
12011        description: str,
12012        group_id: int,
12013        group_scoreboard_id: int,
12014        name: str,
12015        # Ignore any unknown arguments
12016        **_kwargs: Any,
12017    ):
12018        self.alias = alias
12019        self.create_time = create_time
12020        self.description = description
12021        self.group_id = group_id
12022        self.group_scoreboard_id = group_scoreboard_id
12023        self.name = name
12024
12025
12026@dataclasses.dataclass
12027class _ScoreboardEvent:
12028    """_ScoreboardEvent"""
12029    classname: str
12030    country: str
12031    delta: float
12032    is_invited: bool
12033    name: Optional[str]
12034    problem: '_ScoreboardEvent_problem'
12035    total: '_ScoreboardEvent_total'
12036    username: str
12037
12038    def __init__(
12039        self,
12040        *,
12041        classname: str,
12042        country: str,
12043        delta: float,
12044        is_invited: bool,
12045        problem: Dict[str, Any],
12046        total: Dict[str, Any],
12047        username: str,
12048        name: Optional[str] = None,
12049        # Ignore any unknown arguments
12050        **_kwargs: Any,
12051    ):
12052        self.classname = classname
12053        self.country = country
12054        self.delta = delta
12055        self.is_invited = is_invited
12056        if name is not None:
12057            self.name = name
12058        else:
12059            self.name = None
12060        self.problem = _ScoreboardEvent_problem(**problem)
12061        self.total = _ScoreboardEvent_total(**total)
12062        self.username = username
12063
12064
12065@dataclasses.dataclass
12066class _ScoreboardEvent_problem:
12067    """_ScoreboardEvent_problem"""
12068    alias: str
12069    penalty: float
12070    points: float
12071
12072    def __init__(
12073        self,
12074        *,
12075        alias: str,
12076        penalty: float,
12077        points: float,
12078        # Ignore any unknown arguments
12079        **_kwargs: Any,
12080    ):
12081        self.alias = alias
12082        self.penalty = penalty
12083        self.points = points
12084
12085
12086@dataclasses.dataclass
12087class _ScoreboardEvent_total:
12088    """_ScoreboardEvent_total"""
12089    penalty: float
12090    points: float
12091
12092    def __init__(
12093        self,
12094        *,
12095        penalty: float,
12096        points: float,
12097        # Ignore any unknown arguments
12098        **_kwargs: Any,
12099    ):
12100        self.penalty = penalty
12101        self.points = points
12102
12103
12104@dataclasses.dataclass
12105class _ScoreboardMergePayload:
12106    """_ScoreboardMergePayload"""
12107    contests: Sequence['_ContestListItem']
12108
12109    def __init__(
12110        self,
12111        *,
12112        contests: Sequence[Dict[str, Any]],
12113        # Ignore any unknown arguments
12114        **_kwargs: Any,
12115    ):
12116        self.contests = [_ContestListItem(**v) for v in contests]
12117
12118
12119@dataclasses.dataclass
12120class _ScoreboardRanking:
12121    """_ScoreboardRanking"""
12122    contests: Dict[str, '_ScoreboardRanking_contests_value']
12123    name: Optional[str]
12124    total: '_ScoreboardRanking_total'
12125    username: str
12126
12127    def __init__(
12128        self,
12129        *,
12130        contests: Dict[str, Dict[str, Any]],
12131        total: Dict[str, Any],
12132        username: str,
12133        name: Optional[str] = None,
12134        # Ignore any unknown arguments
12135        **_kwargs: Any,
12136    ):
12137        self.contests = {
12138            k: _ScoreboardRanking_contests_value(**v)
12139            for k, v in contests.items()
12140        }
12141        if name is not None:
12142            self.name = name
12143        else:
12144            self.name = None
12145        self.total = _ScoreboardRanking_total(**total)
12146        self.username = username
12147
12148
12149@dataclasses.dataclass
12150class _ScoreboardRankingEntry:
12151    """_ScoreboardRankingEntry"""
12152    classname: str
12153    country: str
12154    is_invited: bool
12155    name: Optional[str]
12156    place: Optional[int]
12157    problems: Sequence['_ScoreboardRankingProblem']
12158    total: '_ScoreboardRankingEntry_total'
12159    username: str
12160
12161    def __init__(
12162        self,
12163        *,
12164        classname: str,
12165        country: str,
12166        is_invited: bool,
12167        problems: Sequence[Dict[str, Any]],
12168        total: Dict[str, Any],
12169        username: str,
12170        name: Optional[str] = None,
12171        place: Optional[int] = None,
12172        # Ignore any unknown arguments
12173        **_kwargs: Any,
12174    ):
12175        self.classname = classname
12176        self.country = country
12177        self.is_invited = is_invited
12178        if name is not None:
12179            self.name = name
12180        else:
12181            self.name = None
12182        if place is not None:
12183            self.place = place
12184        else:
12185            self.place = None
12186        self.problems = [_ScoreboardRankingProblem(**v) for v in problems]
12187        self.total = _ScoreboardRankingEntry_total(**total)
12188        self.username = username
12189
12190
12191@dataclasses.dataclass
12192class _ScoreboardRankingEntry_total:
12193    """_ScoreboardRankingEntry_total"""
12194    penalty: float
12195    points: float
12196
12197    def __init__(
12198        self,
12199        *,
12200        penalty: float,
12201        points: float,
12202        # Ignore any unknown arguments
12203        **_kwargs: Any,
12204    ):
12205        self.penalty = penalty
12206        self.points = points
12207
12208
12209@dataclasses.dataclass
12210class _ScoreboardRankingProblem:
12211    """_ScoreboardRankingProblem"""
12212    alias: str
12213    penalty: float
12214    pending: Optional[int]
12215    percent: float
12216    place: Optional[int]
12217    points: float
12218    run_details: Optional['_ScoreboardRankingProblem_run_details']
12219    runs: int
12220
12221    def __init__(
12222        self,
12223        *,
12224        alias: str,
12225        penalty: float,
12226        percent: float,
12227        points: float,
12228        runs: int,
12229        pending: Optional[int] = None,
12230        place: Optional[int] = None,
12231        run_details: Optional[Dict[str, Any]] = None,
12232        # Ignore any unknown arguments
12233        **_kwargs: Any,
12234    ):
12235        self.alias = alias
12236        self.penalty = penalty
12237        if pending is not None:
12238            self.pending = pending
12239        else:
12240            self.pending = None
12241        self.percent = percent
12242        if place is not None:
12243            self.place = place
12244        else:
12245            self.place = None
12246        self.points = points
12247        if run_details is not None:
12248            self.run_details = _ScoreboardRankingProblem_run_details(
12249                **run_details)
12250        else:
12251            self.run_details = None
12252        self.runs = runs
12253
12254
12255@dataclasses.dataclass
12256class _ScoreboardRankingProblemDetailsGroup:
12257    """_ScoreboardRankingProblemDetailsGroup"""
12258    cases: Sequence['_ScoreboardRankingProblemDetailsGroup_cases_entry']
12259
12260    def __init__(
12261        self,
12262        *,
12263        cases: Sequence[Dict[str, Any]],
12264        # Ignore any unknown arguments
12265        **_kwargs: Any,
12266    ):
12267        self.cases = [
12268            _ScoreboardRankingProblemDetailsGroup_cases_entry(**v)
12269            for v in cases
12270        ]
12271
12272
12273@dataclasses.dataclass
12274class _ScoreboardRankingProblemDetailsGroup_cases_entry:
12275    """_ScoreboardRankingProblemDetailsGroup_cases_entry"""
12276    meta: '_RunMetadata'
12277
12278    def __init__(
12279        self,
12280        *,
12281        meta: Dict[str, Any],
12282        # Ignore any unknown arguments
12283        **_kwargs: Any,
12284    ):
12285        self.meta = _RunMetadata(**meta)
12286
12287
12288@dataclasses.dataclass
12289class _ScoreboardRankingProblem_run_details:
12290    """_ScoreboardRankingProblem_run_details"""
12291    cases: Optional[Sequence['_CaseResult']]
12292    details: '_ScoreboardRankingProblem_run_details_details'
12293
12294    def __init__(
12295        self,
12296        *,
12297        details: Dict[str, Any],
12298        cases: Optional[Sequence[Dict[str, Any]]] = None,
12299        # Ignore any unknown arguments
12300        **_kwargs: Any,
12301    ):
12302        if cases is not None:
12303            self.cases = [_CaseResult(**v) for v in cases]
12304        else:
12305            self.cases = None
12306        self.details = _ScoreboardRankingProblem_run_details_details(**details)
12307
12308
12309@dataclasses.dataclass
12310class _ScoreboardRankingProblem_run_details_details:
12311    """_ScoreboardRankingProblem_run_details_details"""
12312    groups: Sequence['_ScoreboardRankingProblemDetailsGroup']
12313
12314    def __init__(
12315        self,
12316        *,
12317        groups: Sequence[Dict[str, Any]],
12318        # Ignore any unknown arguments
12319        **_kwargs: Any,
12320    ):
12321        self.groups = [
12322            _ScoreboardRankingProblemDetailsGroup(**v) for v in groups
12323        ]
12324
12325
12326@dataclasses.dataclass
12327class _ScoreboardRanking_contests_value:
12328    """_ScoreboardRanking_contests_value"""
12329    penalty: float
12330    points: float
12331
12332    def __init__(
12333        self,
12334        *,
12335        penalty: float,
12336        points: float,
12337        # Ignore any unknown arguments
12338        **_kwargs: Any,
12339    ):
12340        self.penalty = penalty
12341        self.points = points
12342
12343
12344@dataclasses.dataclass
12345class _ScoreboardRanking_total:
12346    """_ScoreboardRanking_total"""
12347    penalty: float
12348    points: float
12349
12350    def __init__(
12351        self,
12352        *,
12353        penalty: float,
12354        points: float,
12355        # Ignore any unknown arguments
12356        **_kwargs: Any,
12357    ):
12358        self.penalty = penalty
12359        self.points = points
12360
12361
12362@dataclasses.dataclass
12363class _Scoreboard_problems_entry:
12364    """_Scoreboard_problems_entry"""
12365    alias: str
12366    order: int
12367
12368    def __init__(
12369        self,
12370        *,
12371        alias: str,
12372        order: int,
12373        # Ignore any unknown arguments
12374        **_kwargs: Any,
12375    ):
12376        self.alias = alias
12377        self.order = order
12378
12379
12380@dataclasses.dataclass
12381class _SelectedTag:
12382    """_SelectedTag"""
12383    public: bool
12384    tagname: str
12385
12386    def __init__(
12387        self,
12388        *,
12389        public: bool,
12390        tagname: str,
12391        # Ignore any unknown arguments
12392        **_kwargs: Any,
12393    ):
12394        self.public = public
12395        self.tagname = tagname
12396
12397
12398@dataclasses.dataclass
12399class _SettingLimits:
12400    """_SettingLimits"""
12401    input_limit: str
12402    memory_limit: str
12403    overall_wall_time_limit: str
12404    time_limit: str
12405
12406    def __init__(
12407        self,
12408        *,
12409        input_limit: str,
12410        memory_limit: str,
12411        overall_wall_time_limit: str,
12412        time_limit: str,
12413        # Ignore any unknown arguments
12414        **_kwargs: Any,
12415    ):
12416        self.input_limit = input_limit
12417        self.memory_limit = memory_limit
12418        self.overall_wall_time_limit = overall_wall_time_limit
12419        self.time_limit = time_limit
12420
12421
12422@dataclasses.dataclass
12423class _Signature:
12424    """_Signature"""
12425    email: str
12426    name: str
12427    time: datetime.datetime
12428
12429    def __init__(
12430        self,
12431        *,
12432        email: str,
12433        name: str,
12434        time: int,
12435        # Ignore any unknown arguments
12436        **_kwargs: Any,
12437    ):
12438        self.email = email
12439        self.name = name
12440        self.time = datetime.datetime.fromtimestamp(time)
12441
12442
12443@dataclasses.dataclass
12444class _StatsPayload:
12445    """_StatsPayload"""
12446    alias: str
12447    cases_stats: Optional[Dict[str, int]]
12448    distribution: Optional[Dict[int, int]]
12449    entity_type: str
12450    max_wait_time: Optional[datetime.datetime]
12451    max_wait_time_guid: Optional[str]
12452    pending_runs: Sequence[str]
12453    size_of_bucket: Optional[float]
12454    total_points: Optional[float]
12455    total_runs: int
12456    verdict_counts: Dict[str, int]
12457
12458    def __init__(
12459        self,
12460        *,
12461        alias: str,
12462        entity_type: str,
12463        pending_runs: Sequence[str],
12464        total_runs: int,
12465        verdict_counts: Dict[str, int],
12466        cases_stats: Optional[Dict[str, int]] = None,
12467        distribution: Optional[Dict[int, int]] = None,
12468        max_wait_time: Optional[int] = None,
12469        max_wait_time_guid: Optional[str] = None,
12470        size_of_bucket: Optional[float] = None,
12471        total_points: Optional[float] = None,
12472        # Ignore any unknown arguments
12473        **_kwargs: Any,
12474    ):
12475        self.alias = alias
12476        if cases_stats is not None:
12477            self.cases_stats = {k: v for k, v in cases_stats.items()}
12478        else:
12479            self.cases_stats = None
12480        if distribution is not None:
12481            self.distribution = {k: v for k, v in distribution.items()}
12482        else:
12483            self.distribution = None
12484        self.entity_type = entity_type
12485        if max_wait_time is not None:
12486            self.max_wait_time = datetime.datetime.fromtimestamp(max_wait_time)
12487        else:
12488            self.max_wait_time = None
12489        if max_wait_time_guid is not None:
12490            self.max_wait_time_guid = max_wait_time_guid
12491        else:
12492            self.max_wait_time_guid = None
12493        self.pending_runs = [v for v in pending_runs]
12494        if size_of_bucket is not None:
12495            self.size_of_bucket = size_of_bucket
12496        else:
12497            self.size_of_bucket = None
12498        if total_points is not None:
12499            self.total_points = total_points
12500        else:
12501            self.total_points = None
12502        self.total_runs = total_runs
12503        self.verdict_counts = {k: v for k, v in verdict_counts.items()}
12504
12505
12506@dataclasses.dataclass
12507class _StudentProgress:
12508    """_StudentProgress"""
12509    classname: str
12510    country_id: Optional[str]
12511    name: Optional[str]
12512    points: Dict[str, Dict[str, float]]
12513    progress: Dict[str, Dict[str, float]]
12514    score: Dict[str, Dict[str, float]]
12515    username: str
12516
12517    def __init__(
12518        self,
12519        *,
12520        classname: str,
12521        points: Dict[str, Dict[str, float]],
12522        progress: Dict[str, Dict[str, float]],
12523        score: Dict[str, Dict[str, float]],
12524        username: str,
12525        country_id: Optional[str] = None,
12526        name: Optional[str] = None,
12527        # Ignore any unknown arguments
12528        **_kwargs: Any,
12529    ):
12530        self.classname = classname
12531        if country_id is not None:
12532            self.country_id = country_id
12533        else:
12534            self.country_id = None
12535        if name is not None:
12536            self.name = name
12537        else:
12538            self.name = None
12539        self.points = {
12540            k: {k: v
12541                for k, v in v.items()}
12542            for k, v in points.items()
12543        }
12544        self.progress = {
12545            k: {k: v
12546                for k, v in v.items()}
12547            for k, v in progress.items()
12548        }
12549        self.score = {
12550            k: {k: v
12551                for k, v in v.items()}
12552            for k, v in score.items()
12553        }
12554        self.username = username
12555
12556
12557@dataclasses.dataclass
12558class _StudentProgressByAssignmentPayload:
12559    """_StudentProgressByAssignmentPayload"""
12560    assignment: str
12561    course: '_CourseDetails'
12562    problems: Sequence['_CourseProblem']
12563    student: str
12564    students: Sequence['_StudentProgress']
12565
12566    def __init__(
12567        self,
12568        *,
12569        assignment: str,
12570        course: Dict[str, Any],
12571        problems: Sequence[Dict[str, Any]],
12572        student: str,
12573        students: Sequence[Dict[str, Any]],
12574        # Ignore any unknown arguments
12575        **_kwargs: Any,
12576    ):
12577        self.assignment = assignment
12578        self.course = _CourseDetails(**course)
12579        self.problems = [_CourseProblem(**v) for v in problems]
12580        self.student = student
12581        self.students = [_StudentProgress(**v) for v in students]
12582
12583
12584@dataclasses.dataclass
12585class _StudentProgressInCourse:
12586    """_StudentProgressInCourse"""
12587    assignments: Dict[str, '_StudentProgressInCourse_assignments_value']
12588    classname: str
12589    country_id: Optional[str]
12590    courseProgress: float
12591    courseScore: float
12592    name: Optional[str]
12593    username: str
12594
12595    def __init__(
12596        self,
12597        *,
12598        assignments: Dict[str, Dict[str, Any]],
12599        classname: str,
12600        courseProgress: float,
12601        courseScore: float,
12602        username: str,
12603        country_id: Optional[str] = None,
12604        name: Optional[str] = None,
12605        # Ignore any unknown arguments
12606        **_kwargs: Any,
12607    ):
12608        self.assignments = {
12609            k: _StudentProgressInCourse_assignments_value(**v)
12610            for k, v in assignments.items()
12611        }
12612        self.classname = classname
12613        if country_id is not None:
12614            self.country_id = country_id
12615        else:
12616            self.country_id = None
12617        self.courseProgress = courseProgress
12618        self.courseScore = courseScore
12619        if name is not None:
12620            self.name = name
12621        else:
12622            self.name = None
12623        self.username = username
12624
12625
12626@dataclasses.dataclass
12627class _StudentProgressInCourse_assignments_value:
12628    """_StudentProgressInCourse_assignments_value"""
12629    problems: Dict[str,
12630                   '_StudentProgressInCourse_assignments_value_problems_value']
12631    progress: float
12632    score: float
12633
12634    def __init__(
12635        self,
12636        *,
12637        problems: Dict[str, Dict[str, Any]],
12638        progress: float,
12639        score: float,
12640        # Ignore any unknown arguments
12641        **_kwargs: Any,
12642    ):
12643        self.problems = {
12644            k: _StudentProgressInCourse_assignments_value_problems_value(**v)
12645            for k, v in problems.items()
12646        }
12647        self.progress = progress
12648        self.score = score
12649
12650
12651@dataclasses.dataclass
12652class _StudentProgressInCourse_assignments_value_problems_value:
12653    """_StudentProgressInCourse_assignments_value_problems_value"""
12654    progress: float
12655    score: float
12656
12657    def __init__(
12658        self,
12659        *,
12660        progress: float,
12661        score: float,
12662        # Ignore any unknown arguments
12663        **_kwargs: Any,
12664    ):
12665        self.progress = progress
12666        self.score = score
12667
12668
12669@dataclasses.dataclass
12670class _StudentProgressPayload:
12671    """_StudentProgressPayload"""
12672    course: '_CourseDetails'
12673    student: str
12674    students: Sequence['_StudentProgress']
12675
12676    def __init__(
12677        self,
12678        *,
12679        course: Dict[str, Any],
12680        student: str,
12681        students: Sequence[Dict[str, Any]],
12682        # Ignore any unknown arguments
12683        **_kwargs: Any,
12684    ):
12685        self.course = _CourseDetails(**course)
12686        self.student = student
12687        self.students = [_StudentProgress(**v) for v in students]
12688
12689
12690@dataclasses.dataclass
12691class _StudentsProgressPayload:
12692    """_StudentsProgressPayload"""
12693    assignmentsProblems: Sequence['_AssignmentsProblemsPoints']
12694    course: '_CourseDetails'
12695    length: int
12696    page: int
12697    pagerItems: Sequence['_PageItem']
12698    students: Sequence['_StudentProgressInCourse']
12699    totalRows: int
12700
12701    def __init__(
12702        self,
12703        *,
12704        assignmentsProblems: Sequence[Dict[str, Any]],
12705        course: Dict[str, Any],
12706        length: int,
12707        page: int,
12708        pagerItems: Sequence[Dict[str, Any]],
12709        students: Sequence[Dict[str, Any]],
12710        totalRows: int,
12711        # Ignore any unknown arguments
12712        **_kwargs: Any,
12713    ):
12714        self.assignmentsProblems = [
12715            _AssignmentsProblemsPoints(**v) for v in assignmentsProblems
12716        ]
12717        self.course = _CourseDetails(**course)
12718        self.length = length
12719        self.page = page
12720        self.pagerItems = [_PageItem(**v) for v in pagerItems]
12721        self.students = [_StudentProgressInCourse(**v) for v in students]
12722        self.totalRows = totalRows
12723
12724
12725@dataclasses.dataclass
12726class _Submission:
12727    """_Submission"""
12728    alias: str
12729    language: str
12730    memory: int
12731    runtime: int
12732    school_id: Optional[int]
12733    school_name: Optional[str]
12734    time: datetime.datetime
12735    title: str
12736    username: str
12737    verdict: str
12738
12739    def __init__(
12740        self,
12741        *,
12742        alias: str,
12743        language: str,
12744        memory: int,
12745        runtime: int,
12746        time: int,
12747        title: str,
12748        username: str,
12749        verdict: str,
12750        school_id: Optional[int] = None,
12751        school_name: Optional[str] = None,
12752        # Ignore any unknown arguments
12753        **_kwargs: Any,
12754    ):
12755        self.alias = alias
12756        self.language = language
12757        self.memory = memory
12758        self.runtime = runtime
12759        if school_id is not None:
12760            self.school_id = school_id
12761        else:
12762            self.school_id = None
12763        if school_name is not None:
12764            self.school_name = school_name
12765        else:
12766            self.school_name = None
12767        self.time = datetime.datetime.fromtimestamp(time)
12768        self.title = title
12769        self.username = username
12770        self.verdict = verdict
12771
12772
12773@dataclasses.dataclass
12774class _SubmissionFeedback:
12775    """_SubmissionFeedback"""
12776    author: str
12777    author_classname: str
12778    date: datetime.datetime
12779    feedback: str
12780
12781    def __init__(
12782        self,
12783        *,
12784        author: str,
12785        author_classname: str,
12786        date: int,
12787        feedback: str,
12788        # Ignore any unknown arguments
12789        **_kwargs: Any,
12790    ):
12791        self.author = author
12792        self.author_classname = author_classname
12793        self.date = datetime.datetime.fromtimestamp(date)
12794        self.feedback = feedback
12795
12796
12797@dataclasses.dataclass
12798class _SubmissionsListPayload:
12799    """_SubmissionsListPayload"""
12800    includeUser: bool
12801    submissions: Sequence['_Submission']
12802
12803    def __init__(
12804        self,
12805        *,
12806        includeUser: bool,
12807        submissions: Sequence[Dict[str, Any]],
12808        # Ignore any unknown arguments
12809        **_kwargs: Any,
12810    ):
12811        self.includeUser = includeUser
12812        self.submissions = [_Submission(**v) for v in submissions]
12813
12814
12815@dataclasses.dataclass
12816class _Tag:
12817    """_Tag"""
12818    name: str
12819
12820    def __init__(
12821        self,
12822        *,
12823        name: str,
12824        # Ignore any unknown arguments
12825        **_kwargs: Any,
12826    ):
12827        self.name = name
12828
12829
12830@dataclasses.dataclass
12831class _TagWithProblemCount:
12832    """_TagWithProblemCount"""
12833    name: str
12834    problemCount: int
12835
12836    def __init__(
12837        self,
12838        *,
12839        name: str,
12840        problemCount: int,
12841        # Ignore any unknown arguments
12842        **_kwargs: Any,
12843    ):
12844        self.name = name
12845        self.problemCount = problemCount
12846
12847
12848@dataclasses.dataclass
12849class _TeamGroupEditPayload:
12850    """_TeamGroupEditPayload"""
12851    countries: Sequence['_OmegaUp_DAO_VO_Countries']
12852    identities: Sequence['_Identity']
12853    isOrganizer: bool
12854    maxNumberOfContestants: int
12855    teamGroup: '_TeamGroupEditPayload_teamGroup'
12856    teamsMembers: Sequence['_TeamMember']
12857
12858    def __init__(
12859        self,
12860        *,
12861        countries: Sequence[Dict[str, Any]],
12862        identities: Sequence[Dict[str, Any]],
12863        isOrganizer: bool,
12864        maxNumberOfContestants: int,
12865        teamGroup: Dict[str, Any],
12866        teamsMembers: Sequence[Dict[str, Any]],
12867        # Ignore any unknown arguments
12868        **_kwargs: Any,
12869    ):
12870        self.countries = [_OmegaUp_DAO_VO_Countries(**v) for v in countries]
12871        self.identities = [_Identity(**v) for v in identities]
12872        self.isOrganizer = isOrganizer
12873        self.maxNumberOfContestants = maxNumberOfContestants
12874        self.teamGroup = _TeamGroupEditPayload_teamGroup(**teamGroup)
12875        self.teamsMembers = [_TeamMember(**v) for v in teamsMembers]
12876
12877
12878@dataclasses.dataclass
12879class _TeamGroupEditPayload_teamGroup:
12880    """_TeamGroupEditPayload_teamGroup"""
12881    alias: str
12882    description: Optional[str]
12883    name: Optional[str]
12884    numberOfContestants: int
12885
12886    def __init__(
12887        self,
12888        *,
12889        alias: str,
12890        numberOfContestants: int,
12891        description: Optional[str] = None,
12892        name: Optional[str] = None,
12893        # Ignore any unknown arguments
12894        **_kwargs: Any,
12895    ):
12896        self.alias = alias
12897        if description is not None:
12898            self.description = description
12899        else:
12900            self.description = None
12901        if name is not None:
12902            self.name = name
12903        else:
12904            self.name = None
12905        self.numberOfContestants = numberOfContestants
12906
12907
12908@dataclasses.dataclass
12909class _TeamGroupNewPayload:
12910    """_TeamGroupNewPayload"""
12911    maxNumberOfContestants: int
12912    numberOfContestants: int
12913
12914    def __init__(
12915        self,
12916        *,
12917        maxNumberOfContestants: int,
12918        numberOfContestants: int,
12919        # Ignore any unknown arguments
12920        **_kwargs: Any,
12921    ):
12922        self.maxNumberOfContestants = maxNumberOfContestants
12923        self.numberOfContestants = numberOfContestants
12924
12925
12926@dataclasses.dataclass
12927class _TeamMember:
12928    """_TeamMember"""
12929    classname: str
12930    isMainUserIdentity: bool
12931    name: Optional[str]
12932    team_alias: str
12933    team_name: Optional[str]
12934    username: str
12935
12936    def __init__(
12937        self,
12938        *,
12939        classname: str,
12940        isMainUserIdentity: bool,
12941        team_alias: str,
12942        username: str,
12943        name: Optional[str] = None,
12944        team_name: Optional[str] = None,
12945        # Ignore any unknown arguments
12946        **_kwargs: Any,
12947    ):
12948        self.classname = classname
12949        self.isMainUserIdentity = isMainUserIdentity
12950        if name is not None:
12951            self.name = name
12952        else:
12953            self.name = None
12954        self.team_alias = team_alias
12955        if team_name is not None:
12956            self.team_name = team_name
12957        else:
12958            self.team_name = None
12959        self.username = username
12960
12961
12962@dataclasses.dataclass
12963class _TeamsGroup:
12964    """_TeamsGroup"""
12965    alias: str
12966    create_time: datetime.datetime
12967    description: Optional[str]
12968    name: str
12969
12970    def __init__(
12971        self,
12972        *,
12973        alias: str,
12974        create_time: int,
12975        name: str,
12976        description: Optional[str] = None,
12977        # Ignore any unknown arguments
12978        **_kwargs: Any,
12979    ):
12980        self.alias = alias
12981        self.create_time = datetime.datetime.fromtimestamp(create_time)
12982        if description is not None:
12983            self.description = description
12984        else:
12985            self.description = None
12986        self.name = name
12987
12988
12989@dataclasses.dataclass
12990class _TeamsGroupListPayload:
12991    """_TeamsGroupListPayload"""
12992    teamsGroups: Sequence['_TeamsGroup']
12993
12994    def __init__(
12995        self,
12996        *,
12997        teamsGroups: Sequence[Dict[str, Any]],
12998        # Ignore any unknown arguments
12999        **_kwargs: Any,
13000    ):
13001        self.teamsGroups = [_TeamsGroup(**v) for v in teamsGroups]
13002
13003
13004@dataclasses.dataclass
13005class _UserDetailsPayload:
13006    """_UserDetailsPayload"""
13007    emails: Sequence[str]
13008    experiments: Sequence[str]
13009    roleNames: Sequence['_UserRole']
13010    systemExperiments: Sequence['_Experiment']
13011    systemRoles: Sequence[str]
13012    username: str
13013    verified: bool
13014
13015    def __init__(
13016        self,
13017        *,
13018        emails: Sequence[str],
13019        experiments: Sequence[str],
13020        roleNames: Sequence[Dict[str, Any]],
13021        systemExperiments: Sequence[Dict[str, Any]],
13022        systemRoles: Sequence[str],
13023        username: str,
13024        verified: bool,
13025        # Ignore any unknown arguments
13026        **_kwargs: Any,
13027    ):
13028        self.emails = [v for v in emails]
13029        self.experiments = [v for v in experiments]
13030        self.roleNames = [_UserRole(**v) for v in roleNames]
13031        self.systemExperiments = [_Experiment(**v) for v in systemExperiments]
13032        self.systemRoles = [v for v in systemRoles]
13033        self.username = username
13034        self.verified = verified
13035
13036
13037@dataclasses.dataclass
13038class _UserInfoForProblem:
13039    """_UserInfoForProblem"""
13040    admin: bool
13041    loggedIn: bool
13042    reviewer: bool
13043
13044    def __init__(
13045        self,
13046        *,
13047        admin: bool,
13048        loggedIn: bool,
13049        reviewer: bool,
13050        # Ignore any unknown arguments
13051        **_kwargs: Any,
13052    ):
13053        self.admin = admin
13054        self.loggedIn = loggedIn
13055        self.reviewer = reviewer
13056
13057
13058@dataclasses.dataclass
13059class _UserProfile:
13060    """_UserProfile"""
13061    birth_date: Optional[datetime.datetime]
13062    classname: str
13063    country: str
13064    country_id: Optional[str]
13065    email: Optional[str]
13066    gender: Optional[str]
13067    graduation_date: Optional[datetime.datetime]
13068    gravatar_92: str
13069    has_competitive_objective: Optional[bool]
13070    has_learning_objective: Optional[bool]
13071    has_scholar_objective: Optional[bool]
13072    has_teaching_objective: Optional[bool]
13073    hide_problem_tags: bool
13074    is_own_profile: bool
13075    is_private: bool
13076    locale: str
13077    name: Optional[str]
13078    preferred_language: Optional[str]
13079    scholar_degree: Optional[str]
13080    school: Optional[str]
13081    school_id: Optional[int]
13082    state: Optional[str]
13083    state_id: Optional[str]
13084    username: Optional[str]
13085    verified: bool
13086
13087    def __init__(
13088        self,
13089        *,
13090        classname: str,
13091        country: str,
13092        gravatar_92: str,
13093        hide_problem_tags: bool,
13094        is_own_profile: bool,
13095        is_private: bool,
13096        locale: str,
13097        verified: bool,
13098        birth_date: Optional[int] = None,
13099        country_id: Optional[str] = None,
13100        email: Optional[str] = None,
13101        gender: Optional[str] = None,
13102        graduation_date: Optional[int] = None,
13103        has_competitive_objective: Optional[bool] = None,
13104        has_learning_objective: Optional[bool] = None,
13105        has_scholar_objective: Optional[bool] = None,
13106        has_teaching_objective: Optional[bool] = None,
13107        name: Optional[str] = None,
13108        preferred_language: Optional[str] = None,
13109        scholar_degree: Optional[str] = None,
13110        school: Optional[str] = None,
13111        school_id: Optional[int] = None,
13112        state: Optional[str] = None,
13113        state_id: Optional[str] = None,
13114        username: Optional[str] = None,
13115        # Ignore any unknown arguments
13116        **_kwargs: Any,
13117    ):
13118        if birth_date is not None:
13119            self.birth_date = datetime.datetime.fromtimestamp(birth_date)
13120        else:
13121            self.birth_date = None
13122        self.classname = classname
13123        self.country = country
13124        if country_id is not None:
13125            self.country_id = country_id
13126        else:
13127            self.country_id = None
13128        if email is not None:
13129            self.email = email
13130        else:
13131            self.email = None
13132        if gender is not None:
13133            self.gender = gender
13134        else:
13135            self.gender = None
13136        if graduation_date is not None:
13137            self.graduation_date = datetime.datetime.fromtimestamp(
13138                graduation_date)
13139        else:
13140            self.graduation_date = None
13141        self.gravatar_92 = gravatar_92
13142        if has_competitive_objective is not None:
13143            self.has_competitive_objective = has_competitive_objective
13144        else:
13145            self.has_competitive_objective = None
13146        if has_learning_objective is not None:
13147            self.has_learning_objective = has_learning_objective
13148        else:
13149            self.has_learning_objective = None
13150        if has_scholar_objective is not None:
13151            self.has_scholar_objective = has_scholar_objective
13152        else:
13153            self.has_scholar_objective = None
13154        if has_teaching_objective is not None:
13155            self.has_teaching_objective = has_teaching_objective
13156        else:
13157            self.has_teaching_objective = None
13158        self.hide_problem_tags = hide_problem_tags
13159        self.is_own_profile = is_own_profile
13160        self.is_private = is_private
13161        self.locale = locale
13162        if name is not None:
13163            self.name = name
13164        else:
13165            self.name = None
13166        if preferred_language is not None:
13167            self.preferred_language = preferred_language
13168        else:
13169            self.preferred_language = None
13170        if scholar_degree is not None:
13171            self.scholar_degree = scholar_degree
13172        else:
13173            self.scholar_degree = None
13174        if school is not None:
13175            self.school = school
13176        else:
13177            self.school = None
13178        if school_id is not None:
13179            self.school_id = school_id
13180        else:
13181            self.school_id = None
13182        if state is not None:
13183            self.state = state
13184        else:
13185            self.state = None
13186        if state_id is not None:
13187            self.state_id = state_id
13188        else:
13189            self.state_id = None
13190        if username is not None:
13191            self.username = username
13192        else:
13193            self.username = None
13194        self.verified = verified
13195
13196
13197@dataclasses.dataclass
13198class _UserProfileContests_value:
13199    """_UserProfileContests_value"""
13200    data: '_ContestParticipated'
13201    place: int
13202
13203    def __init__(
13204        self,
13205        *,
13206        data: Dict[str, Any],
13207        place: int,
13208        # Ignore any unknown arguments
13209        **_kwargs: Any,
13210    ):
13211        self.data = _ContestParticipated(**data)
13212        self.place = place
13213
13214
13215@dataclasses.dataclass
13216class _UserProfileDetailsPayload:
13217    """_UserProfileDetailsPayload"""
13218    countries: Sequence['_OmegaUp_DAO_VO_Countries']
13219    extraProfileDetails: Optional['_ExtraProfileDetails']
13220    identities: Sequence['_AssociatedIdentity']
13221    profile: '_UserProfileInfo'
13222    programmingLanguages: Dict[str, str]
13223
13224    def __init__(
13225        self,
13226        *,
13227        countries: Sequence[Dict[str, Any]],
13228        identities: Sequence[Dict[str, Any]],
13229        profile: Dict[str, Any],
13230        programmingLanguages: Dict[str, str],
13231        extraProfileDetails: Optional[Dict[str, Any]] = None,
13232        # Ignore any unknown arguments
13233        **_kwargs: Any,
13234    ):
13235        self.countries = [_OmegaUp_DAO_VO_Countries(**v) for v in countries]
13236        if extraProfileDetails is not None:
13237            self.extraProfileDetails = _ExtraProfileDetails(
13238                **extraProfileDetails)
13239        else:
13240            self.extraProfileDetails = None
13241        self.identities = [_AssociatedIdentity(**v) for v in identities]
13242        self.profile = _UserProfileInfo(**profile)
13243        self.programmingLanguages = {
13244            k: v
13245            for k, v in programmingLanguages.items()
13246        }
13247
13248
13249@dataclasses.dataclass
13250class _UserProfileInfo:
13251    """_UserProfileInfo"""
13252    birth_date: Optional[datetime.datetime]
13253    classname: str
13254    country: Optional[str]
13255    country_id: Optional[str]
13256    email: Optional[str]
13257    gender: Optional[str]
13258    graduation_date: Optional[datetime.datetime]
13259    gravatar_92: Optional[str]
13260    has_competitive_objective: Optional[bool]
13261    has_learning_objective: Optional[bool]
13262    has_scholar_objective: Optional[bool]
13263    has_teaching_objective: Optional[bool]
13264    hide_problem_tags: bool
13265    is_own_profile: bool
13266    is_private: bool
13267    locale: Optional[str]
13268    name: Optional[str]
13269    preferred_language: Optional[str]
13270    programming_languages: Dict[str, str]
13271    rankinfo: '_UserProfileInfo_rankinfo'
13272    scholar_degree: Optional[str]
13273    school: Optional[str]
13274    school_id: Optional[int]
13275    state: Optional[str]
13276    state_id: Optional[str]
13277    username: Optional[str]
13278    verified: Optional[bool]
13279
13280    def __init__(
13281        self,
13282        *,
13283        classname: str,
13284        hide_problem_tags: bool,
13285        is_own_profile: bool,
13286        is_private: bool,
13287        programming_languages: Dict[str, str],
13288        rankinfo: Dict[str, Any],
13289        birth_date: Optional[int] = None,
13290        country: Optional[str] = None,
13291        country_id: Optional[str] = None,
13292        email: Optional[str] = None,
13293        gender: Optional[str] = None,
13294        graduation_date: Optional[int] = None,
13295        gravatar_92: Optional[str] = None,
13296        has_competitive_objective: Optional[bool] = None,
13297        has_learning_objective: Optional[bool] = None,
13298        has_scholar_objective: Optional[bool] = None,
13299        has_teaching_objective: Optional[bool] = None,
13300        locale: Optional[str] = None,
13301        name: Optional[str] = None,
13302        preferred_language: Optional[str] = None,
13303        scholar_degree: Optional[str] = None,
13304        school: Optional[str] = None,
13305        school_id: Optional[int] = None,
13306        state: Optional[str] = None,
13307        state_id: Optional[str] = None,
13308        username: Optional[str] = None,
13309        verified: Optional[bool] = None,
13310        # Ignore any unknown arguments
13311        **_kwargs: Any,
13312    ):
13313        if birth_date is not None:
13314            self.birth_date = datetime.datetime.fromtimestamp(birth_date)
13315        else:
13316            self.birth_date = None
13317        self.classname = classname
13318        if country is not None:
13319            self.country = country
13320        else:
13321            self.country = None
13322        if country_id is not None:
13323            self.country_id = country_id
13324        else:
13325            self.country_id = None
13326        if email is not None:
13327            self.email = email
13328        else:
13329            self.email = None
13330        if gender is not None:
13331            self.gender = gender
13332        else:
13333            self.gender = None
13334        if graduation_date is not None:
13335            self.graduation_date = datetime.datetime.fromtimestamp(
13336                graduation_date)
13337        else:
13338            self.graduation_date = None
13339        if gravatar_92 is not None:
13340            self.gravatar_92 = gravatar_92
13341        else:
13342            self.gravatar_92 = None
13343        if has_competitive_objective is not None:
13344            self.has_competitive_objective = has_competitive_objective
13345        else:
13346            self.has_competitive_objective = None
13347        if has_learning_objective is not None:
13348            self.has_learning_objective = has_learning_objective
13349        else:
13350            self.has_learning_objective = None
13351        if has_scholar_objective is not None:
13352            self.has_scholar_objective = has_scholar_objective
13353        else:
13354            self.has_scholar_objective = None
13355        if has_teaching_objective is not None:
13356            self.has_teaching_objective = has_teaching_objective
13357        else:
13358            self.has_teaching_objective = None
13359        self.hide_problem_tags = hide_problem_tags
13360        self.is_own_profile = is_own_profile
13361        self.is_private = is_private
13362        if locale is not None:
13363            self.locale = locale
13364        else:
13365            self.locale = None
13366        if name is not None:
13367            self.name = name
13368        else:
13369            self.name = None
13370        if preferred_language is not None:
13371            self.preferred_language = preferred_language
13372        else:
13373            self.preferred_language = None
13374        self.programming_languages = {
13375            k: v
13376            for k, v in programming_languages.items()
13377        }
13378        self.rankinfo = _UserProfileInfo_rankinfo(**rankinfo)
13379        if scholar_degree is not None:
13380            self.scholar_degree = scholar_degree
13381        else:
13382            self.scholar_degree = None
13383        if school is not None:
13384            self.school = school
13385        else:
13386            self.school = None
13387        if school_id is not None:
13388            self.school_id = school_id
13389        else:
13390            self.school_id = None
13391        if state is not None:
13392            self.state = state
13393        else:
13394            self.state = None
13395        if state_id is not None:
13396            self.state_id = state_id
13397        else:
13398            self.state_id = None
13399        if username is not None:
13400            self.username = username
13401        else:
13402            self.username = None
13403        if verified is not None:
13404            self.verified = verified
13405        else:
13406            self.verified = None
13407
13408
13409@dataclasses.dataclass
13410class _UserProfileInfo_rankinfo:
13411    """_UserProfileInfo_rankinfo"""
13412    author_ranking: Optional[int]
13413    name: Optional[str]
13414    problems_solved: Optional[int]
13415    rank: Optional[int]
13416
13417    def __init__(
13418        self,
13419        *,
13420        author_ranking: Optional[int] = None,
13421        name: Optional[str] = None,
13422        problems_solved: Optional[int] = None,
13423        rank: Optional[int] = None,
13424        # Ignore any unknown arguments
13425        **_kwargs: Any,
13426    ):
13427        if author_ranking is not None:
13428            self.author_ranking = author_ranking
13429        else:
13430            self.author_ranking = None
13431        if name is not None:
13432            self.name = name
13433        else:
13434            self.name = None
13435        if problems_solved is not None:
13436            self.problems_solved = problems_solved
13437        else:
13438            self.problems_solved = None
13439        if rank is not None:
13440            self.rank = rank
13441        else:
13442            self.rank = None
13443
13444
13445@dataclasses.dataclass
13446class _UserProfileStats:
13447    """_UserProfileStats"""
13448    date: Optional[str]
13449    runs: int
13450    verdict: str
13451
13452    def __init__(
13453        self,
13454        *,
13455        runs: int,
13456        verdict: str,
13457        date: Optional[str] = None,
13458        # Ignore any unknown arguments
13459        **_kwargs: Any,
13460    ):
13461        if date is not None:
13462            self.date = date
13463        else:
13464            self.date = None
13465        self.runs = runs
13466        self.verdict = verdict
13467
13468
13469@dataclasses.dataclass
13470class _UserRank:
13471    """_UserRank"""
13472    rank: Sequence['_UserRank_rank_entry']
13473    total: int
13474
13475    def __init__(
13476        self,
13477        *,
13478        rank: Sequence[Dict[str, Any]],
13479        total: int,
13480        # Ignore any unknown arguments
13481        **_kwargs: Any,
13482    ):
13483        self.rank = [_UserRank_rank_entry(**v) for v in rank]
13484        self.total = total
13485
13486
13487@dataclasses.dataclass
13488class _UserRankInfo:
13489    """_UserRankInfo"""
13490    author_ranking: Optional[int]
13491    name: str
13492    problems_solved: int
13493    rank: int
13494
13495    def __init__(
13496        self,
13497        *,
13498        name: str,
13499        problems_solved: int,
13500        rank: int,
13501        author_ranking: Optional[int] = None,
13502        # Ignore any unknown arguments
13503        **_kwargs: Any,
13504    ):
13505        if author_ranking is not None:
13506            self.author_ranking = author_ranking
13507        else:
13508            self.author_ranking = None
13509        self.name = name
13510        self.problems_solved = problems_solved
13511        self.rank = rank
13512
13513
13514@dataclasses.dataclass
13515class _UserRankTablePayload:
13516    """_UserRankTablePayload"""
13517    availableFilters: '_UserRankTablePayload_availableFilters'
13518    filter: str
13519    isIndex: bool
13520    isLogged: bool
13521    length: int
13522    page: int
13523    pagerItems: Sequence['_PageItem']
13524    ranking: '_UserRank'
13525
13526    def __init__(
13527        self,
13528        *,
13529        availableFilters: Dict[str, Any],
13530        filter: str,
13531        isIndex: bool,
13532        isLogged: bool,
13533        length: int,
13534        page: int,
13535        pagerItems: Sequence[Dict[str, Any]],
13536        ranking: Dict[str, Any],
13537        # Ignore any unknown arguments
13538        **_kwargs: Any,
13539    ):
13540        self.availableFilters = _UserRankTablePayload_availableFilters(
13541            **availableFilters)
13542        self.filter = filter
13543        self.isIndex = isIndex
13544        self.isLogged = isLogged
13545        self.length = length
13546        self.page = page
13547        self.pagerItems = [_PageItem(**v) for v in pagerItems]
13548        self.ranking = _UserRank(**ranking)
13549
13550
13551@dataclasses.dataclass
13552class _UserRankTablePayload_availableFilters:
13553    """_UserRankTablePayload_availableFilters"""
13554    country: Optional[str]
13555    school: Optional[str]
13556    state: Optional[str]
13557
13558    def __init__(
13559        self,
13560        *,
13561        country: Optional[str] = None,
13562        school: Optional[str] = None,
13563        state: Optional[str] = None,
13564        # Ignore any unknown arguments
13565        **_kwargs: Any,
13566    ):
13567        if country is not None:
13568            self.country = country
13569        else:
13570            self.country = None
13571        if school is not None:
13572            self.school = school
13573        else:
13574            self.school = None
13575        if state is not None:
13576            self.state = state
13577        else:
13578            self.state = None
13579
13580
13581@dataclasses.dataclass
13582class _UserRank_rank_entry:
13583    """_UserRank_rank_entry"""
13584    classname: str
13585    country_id: Optional[str]
13586    name: Optional[str]
13587    problems_solved: int
13588    ranking: Optional[int]
13589    score: float
13590    user_id: int
13591    username: str
13592
13593    def __init__(
13594        self,
13595        *,
13596        classname: str,
13597        problems_solved: int,
13598        score: float,
13599        user_id: int,
13600        username: str,
13601        country_id: Optional[str] = None,
13602        name: Optional[str] = None,
13603        ranking: Optional[int] = None,
13604        # Ignore any unknown arguments
13605        **_kwargs: Any,
13606    ):
13607        self.classname = classname
13608        if country_id is not None:
13609            self.country_id = country_id
13610        else:
13611            self.country_id = None
13612        if name is not None:
13613            self.name = name
13614        else:
13615            self.name = None
13616        self.problems_solved = problems_solved
13617        if ranking is not None:
13618            self.ranking = ranking
13619        else:
13620            self.ranking = None
13621        self.score = score
13622        self.user_id = user_id
13623        self.username = username
13624
13625
13626@dataclasses.dataclass
13627class _UserRole:
13628    """_UserRole"""
13629    name: str
13630
13631    def __init__(
13632        self,
13633        *,
13634        name: str,
13635        # Ignore any unknown arguments
13636        **_kwargs: Any,
13637    ):
13638        self.name = name
13639
13640
13641@dataclasses.dataclass
13642class _UserRolesPayload:
13643    """_UserRolesPayload"""
13644    userSystemGroups: Dict[int, '_UserRolesPayload_userSystemGroups_value']
13645    userSystemRoles: Dict[int, '_UserRolesPayload_userSystemRoles_value']
13646    username: str
13647
13648    def __init__(
13649        self,
13650        *,
13651        userSystemGroups: Dict[int, Dict[str, Any]],
13652        userSystemRoles: Dict[int, Dict[str, Any]],
13653        username: str,
13654        # Ignore any unknown arguments
13655        **_kwargs: Any,
13656    ):
13657        self.userSystemGroups = {
13658            k: _UserRolesPayload_userSystemGroups_value(**v)
13659            for k, v in userSystemGroups.items()
13660        }
13661        self.userSystemRoles = {
13662            k: _UserRolesPayload_userSystemRoles_value(**v)
13663            for k, v in userSystemRoles.items()
13664        }
13665        self.username = username
13666
13667
13668@dataclasses.dataclass
13669class _UserRolesPayload_userSystemGroups_value:
13670    """_UserRolesPayload_userSystemGroups_value"""
13671    name: str
13672    value: bool
13673
13674    def __init__(
13675        self,
13676        *,
13677        name: str,
13678        value: bool,
13679        # Ignore any unknown arguments
13680        **_kwargs: Any,
13681    ):
13682        self.name = name
13683        self.value = value
13684
13685
13686@dataclasses.dataclass
13687class _UserRolesPayload_userSystemRoles_value:
13688    """_UserRolesPayload_userSystemRoles_value"""
13689    name: str
13690    value: bool
13691
13692    def __init__(
13693        self,
13694        *,
13695        name: str,
13696        value: bool,
13697        # Ignore any unknown arguments
13698        **_kwargs: Any,
13699    ):
13700        self.name = name
13701        self.value = value
13702
13703
13704AdminPlatformReportStatsResponse = _OmegaUp_Controllers_Admin__apiPlatformReportStats
13705"""The return type of the AdminPlatformReportStats API."""
13706
13707
13708class Admin:
13709    r"""
13710    """
13711    def __init__(self, client: 'Client') -> None:
13712        self._client = client
13713
13714    def platformReportStats(
13715        self,
13716        *,
13717        end_time: Optional[int] = None,
13718        start_time: Optional[int] = None,
13719        # Out-of-band parameters:
13720        files_: Optional[Mapping[str, BinaryIO]] = None,
13721        check_: bool = True,
13722        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
13723    ) -> AdminPlatformReportStatsResponse:
13724        r"""Get stats for an overall platform report.
13725
13726        Args:
13727            end_time:
13728            start_time:
13729
13730        Returns:
13731            The API result object.
13732        """
13733        parameters: Dict[str, str] = {}
13734        if end_time is not None:
13735            parameters['end_time'] = str(end_time)
13736        if start_time is not None:
13737            parameters['start_time'] = str(start_time)
13738        return _OmegaUp_Controllers_Admin__apiPlatformReportStats(
13739            **self._client.query('/api/admin/platformReportStats/',
13740                                 payload=parameters,
13741                                 files_=files_,
13742                                 timeout_=timeout_,
13743                                 check_=check_))
13744
13745
13746AuthorizationProblemResponse = _OmegaUp_Controllers_Authorization__apiProblem
13747"""The return type of the AuthorizationProblem API."""
13748
13749
13750class Authorization:
13751    r"""AuthorizationController
13752    """
13753    def __init__(self, client: 'Client') -> None:
13754        self._client = client
13755
13756    def problem(
13757        self,
13758        *,
13759        problem_alias: str,
13760        token: str,
13761        username: Optional[Any] = None,
13762        # Out-of-band parameters:
13763        files_: Optional[Mapping[str, BinaryIO]] = None,
13764        check_: bool = True,
13765        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
13766    ) -> AuthorizationProblemResponse:
13767        r"""
13768
13769        Args:
13770            problem_alias:
13771            token:
13772            username:
13773
13774        Returns:
13775            The API result object.
13776        """
13777        parameters: Dict[str, str] = {
13778            'problem_alias': problem_alias,
13779            'token': token,
13780        }
13781        if username is not None:
13782            parameters['username'] = str(username)
13783        return _OmegaUp_Controllers_Authorization__apiProblem(
13784            **self._client.query('/api/authorization/problem/',
13785                                 payload=parameters,
13786                                 files_=files_,
13787                                 timeout_=timeout_,
13788                                 check_=check_))
13789
13790
13791BadgeListResponse = Sequence[str]
13792"""The return type of the BadgeList API."""
13793
13794BadgeMyListResponse = _OmegaUp_Controllers_Badge__apiMyList
13795"""The return type of the BadgeMyList API."""
13796
13797BadgeUserListResponse = _OmegaUp_Controllers_Badge__apiUserList
13798"""The return type of the BadgeUserList API."""
13799
13800BadgeMyBadgeAssignationTimeResponse = _OmegaUp_Controllers_Badge__apiMyBadgeAssignationTime
13801"""The return type of the BadgeMyBadgeAssignationTime API."""
13802
13803BadgeBadgeDetailsResponse = _Badge
13804"""The return type of the BadgeBadgeDetails API."""
13805
13806
13807class Badge:
13808    r"""BadgesController
13809    """
13810    def __init__(self, client: 'Client') -> None:
13811        self._client = client
13812
13813    def list(
13814            self,
13815            *,
13816            # Out-of-band parameters:
13817            files_: Optional[Mapping[str, BinaryIO]] = None,
13818            check_: bool = True,
13819            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
13820    ) -> BadgeListResponse:
13821        r"""Returns a list of existing badges
13822
13823        Returns:
13824            The API result object.
13825        """
13826        parameters: Dict[str, str] = {}
13827        return [
13828            v for v in self._client.query('/api/badge/list/',
13829                                          payload=parameters,
13830                                          files_=files_,
13831                                          timeout_=timeout_,
13832                                          check_=check_)
13833        ]
13834
13835    def myList(
13836        self,
13837        *,
13838        # Out-of-band parameters:
13839        files_: Optional[Mapping[str, BinaryIO]] = None,
13840        check_: bool = True,
13841        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
13842    ) -> BadgeMyListResponse:
13843        r"""Returns a list of badges owned by current user
13844
13845        Returns:
13846            The API result object.
13847        """
13848        parameters: Dict[str, str] = {}
13849        return _OmegaUp_Controllers_Badge__apiMyList(
13850            **self._client.query('/api/badge/myList/',
13851                                 payload=parameters,
13852                                 files_=files_,
13853                                 timeout_=timeout_,
13854                                 check_=check_))
13855
13856    def userList(
13857        self,
13858        *,
13859        target_username: Optional[Any] = None,
13860        # Out-of-band parameters:
13861        files_: Optional[Mapping[str, BinaryIO]] = None,
13862        check_: bool = True,
13863        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
13864    ) -> BadgeUserListResponse:
13865        r"""Returns a list of badges owned by a certain user
13866
13867        Args:
13868            target_username:
13869
13870        Returns:
13871            The API result object.
13872        """
13873        parameters: Dict[str, str] = {}
13874        if target_username is not None:
13875            parameters['target_username'] = str(target_username)
13876        return _OmegaUp_Controllers_Badge__apiUserList(
13877            **self._client.query('/api/badge/userList/',
13878                                 payload=parameters,
13879                                 files_=files_,
13880                                 timeout_=timeout_,
13881                                 check_=check_))
13882
13883    def myBadgeAssignationTime(
13884        self,
13885        *,
13886        badge_alias: Optional[str] = None,
13887        # Out-of-band parameters:
13888        files_: Optional[Mapping[str, BinaryIO]] = None,
13889        check_: bool = True,
13890        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
13891    ) -> BadgeMyBadgeAssignationTimeResponse:
13892        r"""Returns a the assignation timestamp of a badge
13893        for current user.
13894
13895        Args:
13896            badge_alias:
13897
13898        Returns:
13899            The API result object.
13900        """
13901        parameters: Dict[str, str] = {}
13902        if badge_alias is not None:
13903            parameters['badge_alias'] = badge_alias
13904        return _OmegaUp_Controllers_Badge__apiMyBadgeAssignationTime(
13905            **self._client.query('/api/badge/myBadgeAssignationTime/',
13906                                 payload=parameters,
13907                                 files_=files_,
13908                                 timeout_=timeout_,
13909                                 check_=check_))
13910
13911    def badgeDetails(
13912        self,
13913        *,
13914        badge_alias: Optional[str] = None,
13915        # Out-of-band parameters:
13916        files_: Optional[Mapping[str, BinaryIO]] = None,
13917        check_: bool = True,
13918        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
13919    ) -> BadgeBadgeDetailsResponse:
13920        r"""Returns the number of owners and the first
13921        assignation timestamp for a certain badge
13922
13923        Args:
13924            badge_alias:
13925
13926        Returns:
13927            The API result object.
13928        """
13929        parameters: Dict[str, str] = {}
13930        if badge_alias is not None:
13931            parameters['badge_alias'] = badge_alias
13932        return _Badge(**self._client.query('/api/badge/badgeDetails/',
13933                                           payload=parameters,
13934                                           files_=files_,
13935                                           timeout_=timeout_,
13936                                           check_=check_))
13937
13938
13939ClarificationCreateResponse = _Clarification
13940"""The return type of the ClarificationCreate API."""
13941
13942ClarificationDetailsResponse = _OmegaUp_Controllers_Clarification__apiDetails
13943"""The return type of the ClarificationDetails API."""
13944
13945
13946class Clarification:
13947    r"""Description of ClarificationController
13948    """
13949    def __init__(self, client: 'Client') -> None:
13950        self._client = client
13951
13952    def create(
13953        self,
13954        *,
13955        message: str,
13956        problem_alias: str,
13957        assignment_alias: Optional[str] = None,
13958        contest_alias: Optional[str] = None,
13959        course_alias: Optional[str] = None,
13960        username: Optional[str] = None,
13961        # Out-of-band parameters:
13962        files_: Optional[Mapping[str, BinaryIO]] = None,
13963        check_: bool = True,
13964        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
13965    ) -> ClarificationCreateResponse:
13966        r"""Creates a Clarification for a contest or an assignment of a course
13967
13968        Args:
13969            message:
13970            problem_alias:
13971            assignment_alias:
13972            contest_alias:
13973            course_alias:
13974            username:
13975
13976        Returns:
13977            The API result object.
13978        """
13979        parameters: Dict[str, str] = {
13980            'message': message,
13981            'problem_alias': problem_alias,
13982        }
13983        if assignment_alias is not None:
13984            parameters['assignment_alias'] = assignment_alias
13985        if contest_alias is not None:
13986            parameters['contest_alias'] = contest_alias
13987        if course_alias is not None:
13988            parameters['course_alias'] = course_alias
13989        if username is not None:
13990            parameters['username'] = username
13991        return _Clarification(
13992            **self._client.query('/api/clarification/create/',
13993                                 payload=parameters,
13994                                 files_=files_,
13995                                 timeout_=timeout_,
13996                                 check_=check_))
13997
13998    def details(
13999        self,
14000        *,
14001        clarification_id: int,
14002        # Out-of-band parameters:
14003        files_: Optional[Mapping[str, BinaryIO]] = None,
14004        check_: bool = True,
14005        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
14006    ) -> ClarificationDetailsResponse:
14007        r"""API for getting a clarification
14008
14009        Args:
14010            clarification_id:
14011
14012        Returns:
14013            The API result object.
14014        """
14015        parameters: Dict[str, str] = {
14016            'clarification_id': str(clarification_id),
14017        }
14018        return _OmegaUp_Controllers_Clarification__apiDetails(
14019            **self._client.query('/api/clarification/details/',
14020                                 payload=parameters,
14021                                 files_=files_,
14022                                 timeout_=timeout_,
14023                                 check_=check_))
14024
14025    def update(
14026            self,
14027            *,
14028            clarification_id: int,
14029            answer: Optional[str] = None,
14030            message: Optional[str] = None,
14031            public: Optional[bool] = None,
14032            # Out-of-band parameters:
14033            files_: Optional[Mapping[str, BinaryIO]] = None,
14034            check_: bool = True,
14035            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
14036        r"""Update a clarification
14037
14038        Args:
14039            clarification_id:
14040            answer:
14041            message:
14042            public:
14043
14044        Returns:
14045            The API result object.
14046        """
14047        parameters: Dict[str, str] = {
14048            'clarification_id': str(clarification_id),
14049        }
14050        if answer is not None:
14051            parameters['answer'] = answer
14052        if message is not None:
14053            parameters['message'] = message
14054        if public is not None:
14055            parameters['public'] = str(public)
14056        self._client.query('/api/clarification/update/',
14057                           payload=parameters,
14058                           files_=files_,
14059                           timeout_=timeout_,
14060                           check_=check_)
14061
14062
14063ContestListResponse = _OmegaUp_Controllers_Contest__apiList
14064"""The return type of the ContestList API."""
14065
14066ContestAdminListResponse = _OmegaUp_Controllers_Contest__apiAdminList
14067"""The return type of the ContestAdminList API."""
14068
14069ContestMyListResponse = _OmegaUp_Controllers_Contest__apiMyList
14070"""The return type of the ContestMyList API."""
14071
14072ContestListParticipatingResponse = _OmegaUp_Controllers_Contest__apiListParticipating
14073"""The return type of the ContestListParticipating API."""
14074
14075ContestPublicDetailsResponse = _ContestPublicDetails
14076"""The return type of the ContestPublicDetails API."""
14077
14078ContestDetailsResponse = _ContestDetails
14079"""The return type of the ContestDetails API."""
14080
14081ContestAdminDetailsResponse = _ContestAdminDetails
14082"""The return type of the ContestAdminDetails API."""
14083
14084ContestActivityReportResponse = _OmegaUp_Controllers_Contest__apiActivityReport
14085"""The return type of the ContestActivityReport API."""
14086
14087ContestCloneResponse = _OmegaUp_Controllers_Contest__apiClone
14088"""The return type of the ContestClone API."""
14089
14090ContestCreateVirtualResponse = _OmegaUp_Controllers_Contest__apiCreateVirtual
14091"""The return type of the ContestCreateVirtual API."""
14092
14093ContestProblemsResponse = _OmegaUp_Controllers_Contest__apiProblems
14094"""The return type of the ContestProblems API."""
14095
14096ContestRunsDiffResponse = _OmegaUp_Controllers_Contest__apiRunsDiff
14097"""The return type of the ContestRunsDiff API."""
14098
14099ContestClarificationsResponse = _OmegaUp_Controllers_Contest__apiClarifications
14100"""The return type of the ContestClarifications API."""
14101
14102ContestProblemClarificationsResponse = _OmegaUp_Controllers_Contest__apiProblemClarifications
14103"""The return type of the ContestProblemClarifications API."""
14104
14105ContestScoreboardEventsResponse = _OmegaUp_Controllers_Contest__apiScoreboardEvents
14106"""The return type of the ContestScoreboardEvents API."""
14107
14108ContestScoreboardResponse = _Scoreboard
14109"""The return type of the ContestScoreboard API."""
14110
14111ContestScoreboardMergeResponse = _OmegaUp_Controllers_Contest__apiScoreboardMerge
14112"""The return type of the ContestScoreboardMerge API."""
14113
14114ContestRequestsResponse = _OmegaUp_Controllers_Contest__apiRequests
14115"""The return type of the ContestRequests API."""
14116
14117ContestUsersResponse = _OmegaUp_Controllers_Contest__apiUsers
14118"""The return type of the ContestUsers API."""
14119
14120ContestSearchUsersResponse = _OmegaUp_Controllers_Contest__apiSearchUsers
14121"""The return type of the ContestSearchUsers API."""
14122
14123ContestAdminsResponse = _OmegaUp_Controllers_Contest__apiAdmins
14124"""The return type of the ContestAdmins API."""
14125
14126ContestUpdateResponse = _OmegaUp_Controllers_Contest__apiUpdate
14127"""The return type of the ContestUpdate API."""
14128
14129ContestRunsResponse = _OmegaUp_Controllers_Contest__apiRuns
14130"""The return type of the ContestRuns API."""
14131
14132ContestStatsResponse = _OmegaUp_Controllers_Contest__apiStats
14133"""The return type of the ContestStats API."""
14134
14135ContestReportResponse = _OmegaUp_Controllers_Contest__apiReport
14136"""The return type of the ContestReport API."""
14137
14138ContestRoleResponse = _OmegaUp_Controllers_Contest__apiRole
14139"""The return type of the ContestRole API."""
14140
14141ContestContestantsResponse = _OmegaUp_Controllers_Contest__apiContestants
14142"""The return type of the ContestContestants API."""
14143
14144
14145class Contest:
14146    r"""ContestController
14147    """
14148    def __init__(self, client: 'Client') -> None:
14149        self._client = client
14150
14151    def list(
14152        self,
14153        *,
14154        page: int,
14155        page_size: int,
14156        query: str,
14157        tab_name: str,
14158        active: Optional[int] = None,
14159        admission_mode: Optional[Any] = None,
14160        participating: Optional[int] = None,
14161        recommended: Optional[int] = None,
14162        # Out-of-band parameters:
14163        files_: Optional[Mapping[str, BinaryIO]] = None,
14164        check_: bool = True,
14165        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
14166    ) -> ContestListResponse:
14167        r"""Returns a list of contests
14168
14169        Args:
14170            page:
14171            page_size:
14172            query:
14173            tab_name:
14174            active:
14175            admission_mode:
14176            participating:
14177            recommended:
14178
14179        Returns:
14180            The API result object.
14181        """
14182        parameters: Dict[str, str] = {
14183            'page': str(page),
14184            'page_size': str(page_size),
14185            'query': query,
14186            'tab_name': tab_name,
14187        }
14188        if active is not None:
14189            parameters['active'] = str(active)
14190        if admission_mode is not None:
14191            parameters['admission_mode'] = str(admission_mode)
14192        if participating is not None:
14193            parameters['participating'] = str(participating)
14194        if recommended is not None:
14195            parameters['recommended'] = str(recommended)
14196        return _OmegaUp_Controllers_Contest__apiList(
14197            **self._client.query('/api/contest/list/',
14198                                 payload=parameters,
14199                                 files_=files_,
14200                                 timeout_=timeout_,
14201                                 check_=check_))
14202
14203    def adminList(
14204        self,
14205        *,
14206        page: Optional[int] = None,
14207        page_size: Optional[int] = None,
14208        show_archived: Optional[bool] = None,
14209        # Out-of-band parameters:
14210        files_: Optional[Mapping[str, BinaryIO]] = None,
14211        check_: bool = True,
14212        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
14213    ) -> ContestAdminListResponse:
14214        r"""Returns a list of contests where current user has admin rights (or is
14215        the director).
14216
14217        Args:
14218            page:
14219            page_size:
14220            show_archived:
14221
14222        Returns:
14223            The API result object.
14224        """
14225        parameters: Dict[str, str] = {}
14226        if page is not None:
14227            parameters['page'] = str(page)
14228        if page_size is not None:
14229            parameters['page_size'] = str(page_size)
14230        if show_archived is not None:
14231            parameters['show_archived'] = str(show_archived)
14232        return _OmegaUp_Controllers_Contest__apiAdminList(
14233            **self._client.query('/api/contest/adminList/',
14234                                 payload=parameters,
14235                                 files_=files_,
14236                                 timeout_=timeout_,
14237                                 check_=check_))
14238
14239    def myList(
14240        self,
14241        *,
14242        page: Optional[int] = None,
14243        page_size: Optional[int] = None,
14244        query: Optional[str] = None,
14245        show_archived: Optional[bool] = None,
14246        # Out-of-band parameters:
14247        files_: Optional[Mapping[str, BinaryIO]] = None,
14248        check_: bool = True,
14249        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
14250    ) -> ContestMyListResponse:
14251        r"""Returns a list of contests where current user is the director
14252
14253        Args:
14254            page:
14255            page_size:
14256            query:
14257            show_archived:
14258
14259        Returns:
14260            The API result object.
14261        """
14262        parameters: Dict[str, str] = {}
14263        if page is not None:
14264            parameters['page'] = str(page)
14265        if page_size is not None:
14266            parameters['page_size'] = str(page_size)
14267        if query is not None:
14268            parameters['query'] = query
14269        if show_archived is not None:
14270            parameters['show_archived'] = str(show_archived)
14271        return _OmegaUp_Controllers_Contest__apiMyList(
14272            **self._client.query('/api/contest/myList/',
14273                                 payload=parameters,
14274                                 files_=files_,
14275                                 timeout_=timeout_,
14276                                 check_=check_))
14277
14278    def listParticipating(
14279        self,
14280        *,
14281        page: Optional[int] = None,
14282        page_size: Optional[int] = None,
14283        query: Optional[str] = None,
14284        show_archived: Optional[bool] = None,
14285        # Out-of-band parameters:
14286        files_: Optional[Mapping[str, BinaryIO]] = None,
14287        check_: bool = True,
14288        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
14289    ) -> ContestListParticipatingResponse:
14290        r"""Returns a list of contests where current user is participating in
14291
14292        Args:
14293            page:
14294            page_size:
14295            query:
14296            show_archived:
14297
14298        Returns:
14299            The API result object.
14300        """
14301        parameters: Dict[str, str] = {}
14302        if page is not None:
14303            parameters['page'] = str(page)
14304        if page_size is not None:
14305            parameters['page_size'] = str(page_size)
14306        if query is not None:
14307            parameters['query'] = query
14308        if show_archived is not None:
14309            parameters['show_archived'] = str(show_archived)
14310        return _OmegaUp_Controllers_Contest__apiListParticipating(
14311            **self._client.query('/api/contest/listParticipating/',
14312                                 payload=parameters,
14313                                 files_=files_,
14314                                 timeout_=timeout_,
14315                                 check_=check_))
14316
14317    def publicDetails(
14318        self,
14319        *,
14320        contest_alias: str,
14321        # Out-of-band parameters:
14322        files_: Optional[Mapping[str, BinaryIO]] = None,
14323        check_: bool = True,
14324        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
14325    ) -> ContestPublicDetailsResponse:
14326        r"""
14327
14328        Args:
14329            contest_alias:
14330
14331        Returns:
14332            The API result object.
14333        """
14334        parameters: Dict[str, str] = {
14335            'contest_alias': contest_alias,
14336        }
14337        return _ContestPublicDetails(
14338            **self._client.query('/api/contest/publicDetails/',
14339                                 payload=parameters,
14340                                 files_=files_,
14341                                 timeout_=timeout_,
14342                                 check_=check_))
14343
14344    def registerForContest(
14345            self,
14346            *,
14347            contest_alias: str,
14348            # Out-of-band parameters:
14349            files_: Optional[Mapping[str, BinaryIO]] = None,
14350            check_: bool = True,
14351            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
14352        r"""
14353
14354        Args:
14355            contest_alias:
14356
14357        Returns:
14358            The API result object.
14359        """
14360        parameters: Dict[str, str] = {
14361            'contest_alias': contest_alias,
14362        }
14363        self._client.query('/api/contest/registerForContest/',
14364                           payload=parameters,
14365                           files_=files_,
14366                           timeout_=timeout_,
14367                           check_=check_)
14368
14369    def open(
14370            self,
14371            *,
14372            contest_alias: str,
14373            privacy_git_object_id: str,
14374            statement_type: str,
14375            share_user_information: Optional[bool] = None,
14376            token: Optional[str] = None,
14377            # Out-of-band parameters:
14378            files_: Optional[Mapping[str, BinaryIO]] = None,
14379            check_: bool = True,
14380            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
14381        r"""Joins a contest - explicitly adds a identity to a contest.
14382
14383        Args:
14384            contest_alias:
14385            privacy_git_object_id:
14386            statement_type:
14387            share_user_information:
14388            token:
14389
14390        Returns:
14391            The API result object.
14392        """
14393        parameters: Dict[str, str] = {
14394            'contest_alias': contest_alias,
14395            'privacy_git_object_id': privacy_git_object_id,
14396            'statement_type': statement_type,
14397        }
14398        if share_user_information is not None:
14399            parameters['share_user_information'] = str(share_user_information)
14400        if token is not None:
14401            parameters['token'] = token
14402        self._client.query('/api/contest/open/',
14403                           payload=parameters,
14404                           files_=files_,
14405                           timeout_=timeout_,
14406                           check_=check_)
14407
14408    def details(
14409        self,
14410        *,
14411        contest_alias: str,
14412        token: Optional[str] = None,
14413        # Out-of-band parameters:
14414        files_: Optional[Mapping[str, BinaryIO]] = None,
14415        check_: bool = True,
14416        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
14417    ) -> ContestDetailsResponse:
14418        r"""Returns details of a Contest. Requesting the details of a contest will
14419        not start the current user into that contest. In order to participate
14420        in the contest, \OmegaUp\Controllers\Contest::apiOpen() must be used.
14421
14422        Args:
14423            contest_alias:
14424            token:
14425
14426        Returns:
14427            The API result object.
14428        """
14429        parameters: Dict[str, str] = {
14430            'contest_alias': contest_alias,
14431        }
14432        if token is not None:
14433            parameters['token'] = token
14434        return _ContestDetails(**self._client.query('/api/contest/details/',
14435                                                    payload=parameters,
14436                                                    files_=files_,
14437                                                    timeout_=timeout_,
14438                                                    check_=check_))
14439
14440    def adminDetails(
14441        self,
14442        *,
14443        contest_alias: str,
14444        token: Optional[str] = None,
14445        # Out-of-band parameters:
14446        files_: Optional[Mapping[str, BinaryIO]] = None,
14447        check_: bool = True,
14448        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
14449    ) -> ContestAdminDetailsResponse:
14450        r"""Returns details of a Contest, for administrators. This differs from
14451        apiDetails in the sense that it does not attempt to calculate the
14452        remaining time from the contest, or register the opened time.
14453
14454        Args:
14455            contest_alias:
14456            token:
14457
14458        Returns:
14459            The API result object.
14460        """
14461        parameters: Dict[str, str] = {
14462            'contest_alias': contest_alias,
14463        }
14464        if token is not None:
14465            parameters['token'] = token
14466        return _ContestAdminDetails(
14467            **self._client.query('/api/contest/adminDetails/',
14468                                 payload=parameters,
14469                                 files_=files_,
14470                                 timeout_=timeout_,
14471                                 check_=check_))
14472
14473    def activityReport(
14474        self,
14475        *,
14476        contest_alias: str,
14477        length: Optional[int] = None,
14478        page: Optional[int] = None,
14479        token: Optional[str] = None,
14480        # Out-of-band parameters:
14481        files_: Optional[Mapping[str, BinaryIO]] = None,
14482        check_: bool = True,
14483        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
14484    ) -> ContestActivityReportResponse:
14485        r"""Returns a report with all user activity for a contest.
14486
14487        Args:
14488            contest_alias:
14489            length:
14490            page:
14491            token:
14492
14493        Returns:
14494            The API result object.
14495        """
14496        parameters: Dict[str, str] = {
14497            'contest_alias': contest_alias,
14498        }
14499        if length is not None:
14500            parameters['length'] = str(length)
14501        if page is not None:
14502            parameters['page'] = str(page)
14503        if token is not None:
14504            parameters['token'] = token
14505        return _OmegaUp_Controllers_Contest__apiActivityReport(
14506            **self._client.query('/api/contest/activityReport/',
14507                                 payload=parameters,
14508                                 files_=files_,
14509                                 timeout_=timeout_,
14510                                 check_=check_))
14511
14512    def clone(
14513        self,
14514        *,
14515        contest_alias: str,
14516        description: str,
14517        start_time: int,
14518        title: str,
14519        alias: Optional[str] = None,
14520        auth_token: Optional[str] = None,
14521        # Out-of-band parameters:
14522        files_: Optional[Mapping[str, BinaryIO]] = None,
14523        check_: bool = True,
14524        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
14525    ) -> ContestCloneResponse:
14526        r"""Clone a contest
14527
14528        Args:
14529            contest_alias:
14530            description:
14531            start_time:
14532            title:
14533            alias:
14534            auth_token:
14535
14536        Returns:
14537            The API result object.
14538        """
14539        parameters: Dict[str, str] = {
14540            'contest_alias': contest_alias,
14541            'description': description,
14542            'start_time': str(start_time),
14543            'title': title,
14544        }
14545        if alias is not None:
14546            parameters['alias'] = alias
14547        if auth_token is not None:
14548            parameters['auth_token'] = auth_token
14549        return _OmegaUp_Controllers_Contest__apiClone(
14550            **self._client.query('/api/contest/clone/',
14551                                 payload=parameters,
14552                                 files_=files_,
14553                                 timeout_=timeout_,
14554                                 check_=check_))
14555
14556    def createVirtual(
14557        self,
14558        *,
14559        alias: str,
14560        start_time: int,
14561        # Out-of-band parameters:
14562        files_: Optional[Mapping[str, BinaryIO]] = None,
14563        check_: bool = True,
14564        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
14565    ) -> ContestCreateVirtualResponse:
14566        r"""
14567
14568        Args:
14569            alias:
14570            start_time:
14571
14572        Returns:
14573            The API result object.
14574        """
14575        parameters: Dict[str, str] = {
14576            'alias': alias,
14577            'start_time': str(start_time),
14578        }
14579        return _OmegaUp_Controllers_Contest__apiCreateVirtual(
14580            **self._client.query('/api/contest/createVirtual/',
14581                                 payload=parameters,
14582                                 files_=files_,
14583                                 timeout_=timeout_,
14584                                 check_=check_))
14585
14586    def create(
14587            self,
14588            *,
14589            admission_mode: Optional[Any] = None,
14590            alias: Optional[Any] = None,
14591            check_plagiarism: Optional[bool] = None,
14592            contest_for_teams: Optional[bool] = None,
14593            description: Optional[Any] = None,
14594            feedback: Optional[Any] = None,
14595            finish_time: Optional[Any] = None,
14596            languages: Optional[Any] = None,
14597            needs_basic_information: Optional[bool] = None,
14598            partial_score: Optional[bool] = None,
14599            penalty: Optional[Any] = None,
14600            penalty_calc_policy: Optional[Any] = None,
14601            penalty_type: Optional[Any] = None,
14602            points_decay_factor: Optional[Any] = None,
14603            problems: Optional[str] = None,
14604            requests_user_information: Optional[Any] = None,
14605            score_mode: Optional[str] = None,
14606            scoreboard: Optional[Any] = None,
14607            show_scoreboard_after: Optional[Any] = None,
14608            start_time: Optional[Any] = None,
14609            submissions_gap: Optional[Any] = None,
14610            teams_group_alias: Optional[str] = None,
14611            title: Optional[Any] = None,
14612            window_length: Optional[int] = None,
14613            # Out-of-band parameters:
14614            files_: Optional[Mapping[str, BinaryIO]] = None,
14615            check_: bool = True,
14616            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
14617        r"""Creates a new contest
14618
14619        Args:
14620            admission_mode:
14621            alias:
14622            check_plagiarism:
14623            contest_for_teams:
14624            description:
14625            feedback:
14626            finish_time:
14627            languages:
14628            needs_basic_information:
14629            partial_score:
14630            penalty:
14631            penalty_calc_policy:
14632            penalty_type:
14633            points_decay_factor:
14634            problems:
14635            requests_user_information:
14636            score_mode:
14637            scoreboard:
14638            show_scoreboard_after:
14639            start_time:
14640            submissions_gap:
14641            teams_group_alias:
14642            title:
14643            window_length:
14644
14645        Returns:
14646            The API result object.
14647        """
14648        parameters: Dict[str, str] = {}
14649        if admission_mode is not None:
14650            parameters['admission_mode'] = str(admission_mode)
14651        if alias is not None:
14652            parameters['alias'] = str(alias)
14653        if check_plagiarism is not None:
14654            parameters['check_plagiarism'] = str(check_plagiarism)
14655        if contest_for_teams is not None:
14656            parameters['contest_for_teams'] = str(contest_for_teams)
14657        if description is not None:
14658            parameters['description'] = str(description)
14659        if feedback is not None:
14660            parameters['feedback'] = str(feedback)
14661        if finish_time is not None:
14662            parameters['finish_time'] = str(finish_time)
14663        if languages is not None:
14664            parameters['languages'] = str(languages)
14665        if needs_basic_information is not None:
14666            parameters['needs_basic_information'] = str(
14667                needs_basic_information)
14668        if partial_score is not None:
14669            parameters['partial_score'] = str(partial_score)
14670        if penalty is not None:
14671            parameters['penalty'] = str(penalty)
14672        if penalty_calc_policy is not None:
14673            parameters['penalty_calc_policy'] = str(penalty_calc_policy)
14674        if penalty_type is not None:
14675            parameters['penalty_type'] = str(penalty_type)
14676        if points_decay_factor is not None:
14677            parameters['points_decay_factor'] = str(points_decay_factor)
14678        if problems is not None:
14679            parameters['problems'] = problems
14680        if requests_user_information is not None:
14681            parameters['requests_user_information'] = str(
14682                requests_user_information)
14683        if score_mode is not None:
14684            parameters['score_mode'] = score_mode
14685        if scoreboard is not None:
14686            parameters['scoreboard'] = str(scoreboard)
14687        if show_scoreboard_after is not None:
14688            parameters['show_scoreboard_after'] = str(show_scoreboard_after)
14689        if start_time is not None:
14690            parameters['start_time'] = str(start_time)
14691        if submissions_gap is not None:
14692            parameters['submissions_gap'] = str(submissions_gap)
14693        if teams_group_alias is not None:
14694            parameters['teams_group_alias'] = teams_group_alias
14695        if title is not None:
14696            parameters['title'] = str(title)
14697        if window_length is not None:
14698            parameters['window_length'] = str(window_length)
14699        self._client.query('/api/contest/create/',
14700                           payload=parameters,
14701                           files_=files_,
14702                           timeout_=timeout_,
14703                           check_=check_)
14704
14705    def problems(
14706        self,
14707        *,
14708        contest_alias: str,
14709        # Out-of-band parameters:
14710        files_: Optional[Mapping[str, BinaryIO]] = None,
14711        check_: bool = True,
14712        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
14713    ) -> ContestProblemsResponse:
14714        r"""Gets the problems from a contest
14715
14716        Args:
14717            contest_alias:
14718
14719        Returns:
14720            The API result object.
14721        """
14722        parameters: Dict[str, str] = {
14723            'contest_alias': contest_alias,
14724        }
14725        return _OmegaUp_Controllers_Contest__apiProblems(
14726            **self._client.query('/api/contest/problems/',
14727                                 payload=parameters,
14728                                 files_=files_,
14729                                 timeout_=timeout_,
14730                                 check_=check_))
14731
14732    def addProblem(
14733            self,
14734            *,
14735            contest_alias: str,
14736            order_in_contest: int,
14737            points: float,
14738            problem_alias: str,
14739            commit: Optional[str] = None,
14740            # Out-of-band parameters:
14741            files_: Optional[Mapping[str, BinaryIO]] = None,
14742            check_: bool = True,
14743            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
14744        r"""Adds a problem to a contest
14745
14746        Args:
14747            contest_alias:
14748            order_in_contest:
14749            points:
14750            problem_alias:
14751            commit:
14752
14753        Returns:
14754            The API result object.
14755        """
14756        parameters: Dict[str, str] = {
14757            'contest_alias': contest_alias,
14758            'order_in_contest': str(order_in_contest),
14759            'points': str(points),
14760            'problem_alias': problem_alias,
14761        }
14762        if commit is not None:
14763            parameters['commit'] = commit
14764        self._client.query('/api/contest/addProblem/',
14765                           payload=parameters,
14766                           files_=files_,
14767                           timeout_=timeout_,
14768                           check_=check_)
14769
14770    def removeProblem(
14771            self,
14772            *,
14773            contest_alias: str,
14774            problem_alias: str,
14775            # Out-of-band parameters:
14776            files_: Optional[Mapping[str, BinaryIO]] = None,
14777            check_: bool = True,
14778            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
14779        r"""Removes a problem from a contest
14780
14781        Args:
14782            contest_alias:
14783            problem_alias:
14784
14785        Returns:
14786            The API result object.
14787        """
14788        parameters: Dict[str, str] = {
14789            'contest_alias': contest_alias,
14790            'problem_alias': problem_alias,
14791        }
14792        self._client.query('/api/contest/removeProblem/',
14793                           payload=parameters,
14794                           files_=files_,
14795                           timeout_=timeout_,
14796                           check_=check_)
14797
14798    def runsDiff(
14799        self,
14800        *,
14801        contest_alias: str,
14802        version: str,
14803        problem_alias: Optional[str] = None,
14804        # Out-of-band parameters:
14805        files_: Optional[Mapping[str, BinaryIO]] = None,
14806        check_: bool = True,
14807        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
14808    ) -> ContestRunsDiffResponse:
14809        r"""Return a report of which runs would change due to a version change.
14810
14811        Args:
14812            contest_alias:
14813            version:
14814            problem_alias:
14815
14816        Returns:
14817            The API result object.
14818        """
14819        parameters: Dict[str, str] = {
14820            'contest_alias': contest_alias,
14821            'version': version,
14822        }
14823        if problem_alias is not None:
14824            parameters['problem_alias'] = problem_alias
14825        return _OmegaUp_Controllers_Contest__apiRunsDiff(
14826            **self._client.query('/api/contest/runsDiff/',
14827                                 payload=parameters,
14828                                 files_=files_,
14829                                 timeout_=timeout_,
14830                                 check_=check_))
14831
14832    def addUser(
14833            self,
14834            *,
14835            contest_alias: str,
14836            usernameOrEmail: str,
14837            # Out-of-band parameters:
14838            files_: Optional[Mapping[str, BinaryIO]] = None,
14839            check_: bool = True,
14840            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
14841        r"""Adds a user to a contest.
14842        By default, any user can view details of public contests.
14843        Only users added through this API can view private contests
14844
14845        Args:
14846            contest_alias:
14847            usernameOrEmail:
14848
14849        Returns:
14850            The API result object.
14851        """
14852        parameters: Dict[str, str] = {
14853            'contest_alias': contest_alias,
14854            'usernameOrEmail': usernameOrEmail,
14855        }
14856        self._client.query('/api/contest/addUser/',
14857                           payload=parameters,
14858                           files_=files_,
14859                           timeout_=timeout_,
14860                           check_=check_)
14861
14862    def removeUser(
14863            self,
14864            *,
14865            contest_alias: str,
14866            usernameOrEmail: str,
14867            # Out-of-band parameters:
14868            files_: Optional[Mapping[str, BinaryIO]] = None,
14869            check_: bool = True,
14870            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
14871        r"""Remove a user from a private contest
14872
14873        Args:
14874            contest_alias:
14875            usernameOrEmail:
14876
14877        Returns:
14878            The API result object.
14879        """
14880        parameters: Dict[str, str] = {
14881            'contest_alias': contest_alias,
14882            'usernameOrEmail': usernameOrEmail,
14883        }
14884        self._client.query('/api/contest/removeUser/',
14885                           payload=parameters,
14886                           files_=files_,
14887                           timeout_=timeout_,
14888                           check_=check_)
14889
14890    def replaceTeamsGroup(
14891            self,
14892            *,
14893            contest_alias: str,
14894            teams_group_alias: str,
14895            # Out-of-band parameters:
14896            files_: Optional[Mapping[str, BinaryIO]] = None,
14897            check_: bool = True,
14898            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
14899        r"""Replace the teams group assigned to a contest
14900
14901        Args:
14902            contest_alias: The alias of the contest
14903            teams_group_alias: The alias of the teams group
14904
14905        Returns:
14906            The API result object.
14907        """
14908        parameters: Dict[str, str] = {
14909            'contest_alias': contest_alias,
14910            'teams_group_alias': teams_group_alias,
14911        }
14912        self._client.query('/api/contest/replaceTeamsGroup/',
14913                           payload=parameters,
14914                           files_=files_,
14915                           timeout_=timeout_,
14916                           check_=check_)
14917
14918    def addGroup(
14919            self,
14920            *,
14921            contest_alias: str,
14922            group: str,
14923            # Out-of-band parameters:
14924            files_: Optional[Mapping[str, BinaryIO]] = None,
14925            check_: bool = True,
14926            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
14927        r"""Adds a group to a contest
14928
14929        Args:
14930            contest_alias:
14931            group:
14932
14933        Returns:
14934            The API result object.
14935        """
14936        parameters: Dict[str, str] = {
14937            'contest_alias': contest_alias,
14938            'group': group,
14939        }
14940        self._client.query('/api/contest/addGroup/',
14941                           payload=parameters,
14942                           files_=files_,
14943                           timeout_=timeout_,
14944                           check_=check_)
14945
14946    def removeGroup(
14947            self,
14948            *,
14949            contest_alias: str,
14950            group: str,
14951            # Out-of-band parameters:
14952            files_: Optional[Mapping[str, BinaryIO]] = None,
14953            check_: bool = True,
14954            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
14955        r"""Removes a group from a contest
14956
14957        Args:
14958            contest_alias:
14959            group:
14960
14961        Returns:
14962            The API result object.
14963        """
14964        parameters: Dict[str, str] = {
14965            'contest_alias': contest_alias,
14966            'group': group,
14967        }
14968        self._client.query('/api/contest/removeGroup/',
14969                           payload=parameters,
14970                           files_=files_,
14971                           timeout_=timeout_,
14972                           check_=check_)
14973
14974    def addAdmin(
14975            self,
14976            *,
14977            contest_alias: str,
14978            usernameOrEmail: str,
14979            # Out-of-band parameters:
14980            files_: Optional[Mapping[str, BinaryIO]] = None,
14981            check_: bool = True,
14982            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
14983        r"""Adds an admin to a contest
14984
14985        Args:
14986            contest_alias:
14987            usernameOrEmail:
14988
14989        Returns:
14990            The API result object.
14991        """
14992        parameters: Dict[str, str] = {
14993            'contest_alias': contest_alias,
14994            'usernameOrEmail': usernameOrEmail,
14995        }
14996        self._client.query('/api/contest/addAdmin/',
14997                           payload=parameters,
14998                           files_=files_,
14999                           timeout_=timeout_,
15000                           check_=check_)
15001
15002    def removeAdmin(
15003            self,
15004            *,
15005            contest_alias: str,
15006            usernameOrEmail: str,
15007            # Out-of-band parameters:
15008            files_: Optional[Mapping[str, BinaryIO]] = None,
15009            check_: bool = True,
15010            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
15011        r"""Removes an admin from a contest
15012
15013        Args:
15014            contest_alias:
15015            usernameOrEmail:
15016
15017        Returns:
15018            The API result object.
15019        """
15020        parameters: Dict[str, str] = {
15021            'contest_alias': contest_alias,
15022            'usernameOrEmail': usernameOrEmail,
15023        }
15024        self._client.query('/api/contest/removeAdmin/',
15025                           payload=parameters,
15026                           files_=files_,
15027                           timeout_=timeout_,
15028                           check_=check_)
15029
15030    def addGroupAdmin(
15031            self,
15032            *,
15033            contest_alias: str,
15034            group: str,
15035            # Out-of-band parameters:
15036            files_: Optional[Mapping[str, BinaryIO]] = None,
15037            check_: bool = True,
15038            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
15039        r"""Adds a group admin to a contest
15040
15041        Args:
15042            contest_alias:
15043            group:
15044
15045        Returns:
15046            The API result object.
15047        """
15048        parameters: Dict[str, str] = {
15049            'contest_alias': contest_alias,
15050            'group': group,
15051        }
15052        self._client.query('/api/contest/addGroupAdmin/',
15053                           payload=parameters,
15054                           files_=files_,
15055                           timeout_=timeout_,
15056                           check_=check_)
15057
15058    def removeGroupAdmin(
15059            self,
15060            *,
15061            contest_alias: str,
15062            group: str,
15063            # Out-of-band parameters:
15064            files_: Optional[Mapping[str, BinaryIO]] = None,
15065            check_: bool = True,
15066            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
15067        r"""Removes a group admin from a contest
15068
15069        Args:
15070            contest_alias:
15071            group:
15072
15073        Returns:
15074            The API result object.
15075        """
15076        parameters: Dict[str, str] = {
15077            'contest_alias': contest_alias,
15078            'group': group,
15079        }
15080        self._client.query('/api/contest/removeGroupAdmin/',
15081                           payload=parameters,
15082                           files_=files_,
15083                           timeout_=timeout_,
15084                           check_=check_)
15085
15086    def clarifications(
15087        self,
15088        *,
15089        contest_alias: str,
15090        offset: int,
15091        rowcount: int,
15092        # Out-of-band parameters:
15093        files_: Optional[Mapping[str, BinaryIO]] = None,
15094        check_: bool = True,
15095        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
15096    ) -> ContestClarificationsResponse:
15097        r"""Get clarifications of a contest
15098
15099        Args:
15100            contest_alias:
15101            offset:
15102            rowcount:
15103
15104        Returns:
15105            The API result object.
15106        """
15107        parameters: Dict[str, str] = {
15108            'contest_alias': contest_alias,
15109            'offset': str(offset),
15110            'rowcount': str(rowcount),
15111        }
15112        return _OmegaUp_Controllers_Contest__apiClarifications(
15113            **self._client.query('/api/contest/clarifications/',
15114                                 payload=parameters,
15115                                 files_=files_,
15116                                 timeout_=timeout_,
15117                                 check_=check_))
15118
15119    def problemClarifications(
15120        self,
15121        *,
15122        contest_alias: str,
15123        offset: int,
15124        problem_alias: str,
15125        rowcount: int,
15126        # Out-of-band parameters:
15127        files_: Optional[Mapping[str, BinaryIO]] = None,
15128        check_: bool = True,
15129        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
15130    ) -> ContestProblemClarificationsResponse:
15131        r"""Get clarifications of problem in a contest
15132
15133        Args:
15134            contest_alias:
15135            offset:
15136            problem_alias:
15137            rowcount:
15138
15139        Returns:
15140            The API result object.
15141        """
15142        parameters: Dict[str, str] = {
15143            'contest_alias': contest_alias,
15144            'offset': str(offset),
15145            'problem_alias': problem_alias,
15146            'rowcount': str(rowcount),
15147        }
15148        return _OmegaUp_Controllers_Contest__apiProblemClarifications(
15149            **self._client.query('/api/contest/problemClarifications/',
15150                                 payload=parameters,
15151                                 files_=files_,
15152                                 timeout_=timeout_,
15153                                 check_=check_))
15154
15155    def scoreboardEvents(
15156        self,
15157        *,
15158        contest_alias: str,
15159        token: Optional[str] = None,
15160        # Out-of-band parameters:
15161        files_: Optional[Mapping[str, BinaryIO]] = None,
15162        check_: bool = True,
15163        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
15164    ) -> ContestScoreboardEventsResponse:
15165        r"""Returns the Scoreboard events
15166
15167        Args:
15168            contest_alias:
15169            token:
15170
15171        Returns:
15172            The API result object.
15173        """
15174        parameters: Dict[str, str] = {
15175            'contest_alias': contest_alias,
15176        }
15177        if token is not None:
15178            parameters['token'] = token
15179        return _OmegaUp_Controllers_Contest__apiScoreboardEvents(
15180            **self._client.query('/api/contest/scoreboardEvents/',
15181                                 payload=parameters,
15182                                 files_=files_,
15183                                 timeout_=timeout_,
15184                                 check_=check_))
15185
15186    def scoreboard(
15187        self,
15188        *,
15189        contest_alias: str,
15190        token: Optional[str] = None,
15191        # Out-of-band parameters:
15192        files_: Optional[Mapping[str, BinaryIO]] = None,
15193        check_: bool = True,
15194        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
15195    ) -> ContestScoreboardResponse:
15196        r"""Returns the Scoreboard
15197
15198        Args:
15199            contest_alias:
15200            token:
15201
15202        Returns:
15203            The API result object.
15204        """
15205        parameters: Dict[str, str] = {
15206            'contest_alias': contest_alias,
15207        }
15208        if token is not None:
15209            parameters['token'] = token
15210        return _Scoreboard(**self._client.query('/api/contest/scoreboard/',
15211                                                payload=parameters,
15212                                                files_=files_,
15213                                                timeout_=timeout_,
15214                                                check_=check_))
15215
15216    def scoreboardMerge(
15217        self,
15218        *,
15219        contest_aliases: str,
15220        contest_params: Optional[Any] = None,
15221        usernames_filter: Optional[str] = None,
15222        # Out-of-band parameters:
15223        files_: Optional[Mapping[str, BinaryIO]] = None,
15224        check_: bool = True,
15225        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
15226    ) -> ContestScoreboardMergeResponse:
15227        r"""Gets the accomulative scoreboard for an array of contests
15228
15229        Args:
15230            contest_aliases:
15231            contest_params:
15232            usernames_filter:
15233
15234        Returns:
15235            The API result object.
15236        """
15237        parameters: Dict[str, str] = {
15238            'contest_aliases': contest_aliases,
15239        }
15240        if contest_params is not None:
15241            parameters['contest_params'] = str(contest_params)
15242        if usernames_filter is not None:
15243            parameters['usernames_filter'] = usernames_filter
15244        return _OmegaUp_Controllers_Contest__apiScoreboardMerge(
15245            **self._client.query('/api/contest/scoreboardMerge/',
15246                                 payload=parameters,
15247                                 files_=files_,
15248                                 timeout_=timeout_,
15249                                 check_=check_))
15250
15251    def requests(
15252        self,
15253        *,
15254        contest_alias: str,
15255        # Out-of-band parameters:
15256        files_: Optional[Mapping[str, BinaryIO]] = None,
15257        check_: bool = True,
15258        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
15259    ) -> ContestRequestsResponse:
15260        r"""
15261
15262        Args:
15263            contest_alias:
15264
15265        Returns:
15266            The API result object.
15267        """
15268        parameters: Dict[str, str] = {
15269            'contest_alias': contest_alias,
15270        }
15271        return _OmegaUp_Controllers_Contest__apiRequests(
15272            **self._client.query('/api/contest/requests/',
15273                                 payload=parameters,
15274                                 files_=files_,
15275                                 timeout_=timeout_,
15276                                 check_=check_))
15277
15278    def arbitrateRequest(
15279            self,
15280            *,
15281            contest_alias: str,
15282            username: str,
15283            note: Optional[str] = None,
15284            resolution: Optional[Any] = None,
15285            # Out-of-band parameters:
15286            files_: Optional[Mapping[str, BinaryIO]] = None,
15287            check_: bool = True,
15288            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
15289        r"""
15290
15291        Args:
15292            contest_alias:
15293            username:
15294            note:
15295            resolution:
15296
15297        Returns:
15298            The API result object.
15299        """
15300        parameters: Dict[str, str] = {
15301            'contest_alias': contest_alias,
15302            'username': username,
15303        }
15304        if note is not None:
15305            parameters['note'] = note
15306        if resolution is not None:
15307            parameters['resolution'] = str(resolution)
15308        self._client.query('/api/contest/arbitrateRequest/',
15309                           payload=parameters,
15310                           files_=files_,
15311                           timeout_=timeout_,
15312                           check_=check_)
15313
15314    def users(
15315        self,
15316        *,
15317        contest_alias: str,
15318        # Out-of-band parameters:
15319        files_: Optional[Mapping[str, BinaryIO]] = None,
15320        check_: bool = True,
15321        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
15322    ) -> ContestUsersResponse:
15323        r"""Returns ALL identities participating in a contest
15324
15325        Args:
15326            contest_alias:
15327
15328        Returns:
15329            The API result object.
15330        """
15331        parameters: Dict[str, str] = {
15332            'contest_alias': contest_alias,
15333        }
15334        return _OmegaUp_Controllers_Contest__apiUsers(
15335            **self._client.query('/api/contest/users/',
15336                                 payload=parameters,
15337                                 files_=files_,
15338                                 timeout_=timeout_,
15339                                 check_=check_))
15340
15341    def searchUsers(
15342        self,
15343        *,
15344        contest_alias: str,
15345        query: Optional[str] = None,
15346        # Out-of-band parameters:
15347        files_: Optional[Mapping[str, BinaryIO]] = None,
15348        check_: bool = True,
15349        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
15350    ) -> ContestSearchUsersResponse:
15351        r"""Search users in contest
15352
15353        Args:
15354            contest_alias:
15355            query:
15356
15357        Returns:
15358            The API result object.
15359        """
15360        parameters: Dict[str, str] = {
15361            'contest_alias': contest_alias,
15362        }
15363        if query is not None:
15364            parameters['query'] = query
15365        return _OmegaUp_Controllers_Contest__apiSearchUsers(
15366            **self._client.query('/api/contest/searchUsers/',
15367                                 payload=parameters,
15368                                 files_=files_,
15369                                 timeout_=timeout_,
15370                                 check_=check_))
15371
15372    def admins(
15373        self,
15374        *,
15375        contest_alias: str,
15376        # Out-of-band parameters:
15377        files_: Optional[Mapping[str, BinaryIO]] = None,
15378        check_: bool = True,
15379        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
15380    ) -> ContestAdminsResponse:
15381        r"""Returns all contest administrators
15382
15383        Args:
15384            contest_alias:
15385
15386        Returns:
15387            The API result object.
15388        """
15389        parameters: Dict[str, str] = {
15390            'contest_alias': contest_alias,
15391        }
15392        return _OmegaUp_Controllers_Contest__apiAdmins(
15393            **self._client.query('/api/contest/admins/',
15394                                 payload=parameters,
15395                                 files_=files_,
15396                                 timeout_=timeout_,
15397                                 check_=check_))
15398
15399    def update(
15400        self,
15401        *,
15402        contest_alias: str,
15403        finish_time: int,
15404        submissions_gap: int,
15405        window_length: int,
15406        admission_mode: Optional[str] = None,
15407        alias: Optional[str] = None,
15408        check_plagiarism: Optional[bool] = None,
15409        contest_for_teams: Optional[bool] = None,
15410        default_show_all_contestants_in_scoreboard: Optional[bool] = None,
15411        description: Optional[str] = None,
15412        feedback: Optional[Any] = None,
15413        languages: Optional[Any] = None,
15414        needs_basic_information: Optional[bool] = None,
15415        partial_score: Optional[bool] = None,
15416        penalty: Optional[int] = None,
15417        penalty_calc_policy: Optional[Any] = None,
15418        penalty_type: Optional[Any] = None,
15419        points_decay_factor: Optional[float] = None,
15420        problems: Optional[str] = None,
15421        requests_user_information: Optional[str] = None,
15422        score_mode: Optional[str] = None,
15423        scoreboard: Optional[float] = None,
15424        show_scoreboard_after: Optional[bool] = None,
15425        start_time: Optional[datetime.datetime] = None,
15426        teams_group_alias: Optional[str] = None,
15427        title: Optional[str] = None,
15428        # Out-of-band parameters:
15429        files_: Optional[Mapping[str, BinaryIO]] = None,
15430        check_: bool = True,
15431        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
15432    ) -> ContestUpdateResponse:
15433        r"""Update a Contest
15434
15435        Args:
15436            contest_alias:
15437            finish_time:
15438            submissions_gap:
15439            window_length:
15440            admission_mode:
15441            alias:
15442            check_plagiarism:
15443            contest_for_teams:
15444            default_show_all_contestants_in_scoreboard:
15445            description:
15446            feedback:
15447            languages:
15448            needs_basic_information:
15449            partial_score:
15450            penalty:
15451            penalty_calc_policy:
15452            penalty_type:
15453            points_decay_factor:
15454            problems:
15455            requests_user_information:
15456            score_mode:
15457            scoreboard:
15458            show_scoreboard_after:
15459            start_time:
15460            teams_group_alias:
15461            title:
15462
15463        Returns:
15464            The API result object.
15465        """
15466        parameters: Dict[str, str] = {
15467            'contest_alias': contest_alias,
15468            'finish_time': str(finish_time),
15469            'submissions_gap': str(submissions_gap),
15470            'window_length': str(window_length),
15471        }
15472        if admission_mode is not None:
15473            parameters['admission_mode'] = admission_mode
15474        if alias is not None:
15475            parameters['alias'] = alias
15476        if check_plagiarism is not None:
15477            parameters['check_plagiarism'] = str(check_plagiarism)
15478        if contest_for_teams is not None:
15479            parameters['contest_for_teams'] = str(contest_for_teams)
15480        if default_show_all_contestants_in_scoreboard is not None:
15481            parameters['default_show_all_contestants_in_scoreboard'] = str(
15482                default_show_all_contestants_in_scoreboard)
15483        if description is not None:
15484            parameters['description'] = description
15485        if feedback is not None:
15486            parameters['feedback'] = str(feedback)
15487        if languages is not None:
15488            parameters['languages'] = str(languages)
15489        if needs_basic_information is not None:
15490            parameters['needs_basic_information'] = str(
15491                needs_basic_information)
15492        if partial_score is not None:
15493            parameters['partial_score'] = str(partial_score)
15494        if penalty is not None:
15495            parameters['penalty'] = str(penalty)
15496        if penalty_calc_policy is not None:
15497            parameters['penalty_calc_policy'] = str(penalty_calc_policy)
15498        if penalty_type is not None:
15499            parameters['penalty_type'] = str(penalty_type)
15500        if points_decay_factor is not None:
15501            parameters['points_decay_factor'] = str(points_decay_factor)
15502        if problems is not None:
15503            parameters['problems'] = problems
15504        if requests_user_information is not None:
15505            parameters['requests_user_information'] = requests_user_information
15506        if score_mode is not None:
15507            parameters['score_mode'] = score_mode
15508        if scoreboard is not None:
15509            parameters['scoreboard'] = str(scoreboard)
15510        if show_scoreboard_after is not None:
15511            parameters['show_scoreboard_after'] = str(show_scoreboard_after)
15512        if start_time is not None:
15513            parameters['start_time'] = str(int(start_time.timestamp()))
15514        if teams_group_alias is not None:
15515            parameters['teams_group_alias'] = teams_group_alias
15516        if title is not None:
15517            parameters['title'] = title
15518        return _OmegaUp_Controllers_Contest__apiUpdate(
15519            **self._client.query('/api/contest/update/',
15520                                 payload=parameters,
15521                                 files_=files_,
15522                                 timeout_=timeout_,
15523                                 check_=check_))
15524
15525    def updateEndTimeForIdentity(
15526            self,
15527            *,
15528            contest_alias: str,
15529            end_time: datetime.datetime,
15530            username: str,
15531            # Out-of-band parameters:
15532            files_: Optional[Mapping[str, BinaryIO]] = None,
15533            check_: bool = True,
15534            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
15535        r"""Update Contest end time for an identity when window_length
15536        option is turned on
15537
15538        Args:
15539            contest_alias:
15540            end_time:
15541            username:
15542
15543        Returns:
15544            The API result object.
15545        """
15546        parameters: Dict[str, str] = {
15547            'contest_alias': contest_alias,
15548            'end_time': str(int(end_time.timestamp())),
15549            'username': username,
15550        }
15551        self._client.query('/api/contest/updateEndTimeForIdentity/',
15552                           payload=parameters,
15553                           files_=files_,
15554                           timeout_=timeout_,
15555                           check_=check_)
15556
15557    def runs(
15558        self,
15559        *,
15560        contest_alias: str,
15561        problem_alias: str,
15562        language: Optional[str] = None,
15563        offset: Optional[int] = None,
15564        rowcount: Optional[int] = None,
15565        status: Optional[str] = None,
15566        username: Optional[str] = None,
15567        verdict: Optional[str] = None,
15568        # Out-of-band parameters:
15569        files_: Optional[Mapping[str, BinaryIO]] = None,
15570        check_: bool = True,
15571        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
15572    ) -> ContestRunsResponse:
15573        r"""Returns all runs for a contest
15574
15575        Args:
15576            contest_alias:
15577            problem_alias:
15578            language:
15579            offset:
15580            rowcount:
15581            status:
15582            username:
15583            verdict:
15584
15585        Returns:
15586            The API result object.
15587        """
15588        parameters: Dict[str, str] = {
15589            'contest_alias': contest_alias,
15590            'problem_alias': problem_alias,
15591        }
15592        if language is not None:
15593            parameters['language'] = language
15594        if offset is not None:
15595            parameters['offset'] = str(offset)
15596        if rowcount is not None:
15597            parameters['rowcount'] = str(rowcount)
15598        if status is not None:
15599            parameters['status'] = status
15600        if username is not None:
15601            parameters['username'] = username
15602        if verdict is not None:
15603            parameters['verdict'] = verdict
15604        return _OmegaUp_Controllers_Contest__apiRuns(
15605            **self._client.query('/api/contest/runs/',
15606                                 payload=parameters,
15607                                 files_=files_,
15608                                 timeout_=timeout_,
15609                                 check_=check_))
15610
15611    def stats(
15612        self,
15613        *,
15614        contest_alias: Optional[str] = None,
15615        # Out-of-band parameters:
15616        files_: Optional[Mapping[str, BinaryIO]] = None,
15617        check_: bool = True,
15618        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
15619    ) -> ContestStatsResponse:
15620        r"""Stats of a contest
15621
15622        Args:
15623            contest_alias:
15624
15625        Returns:
15626            The API result object.
15627        """
15628        parameters: Dict[str, str] = {}
15629        if contest_alias is not None:
15630            parameters['contest_alias'] = contest_alias
15631        return _OmegaUp_Controllers_Contest__apiStats(
15632            **self._client.query('/api/contest/stats/',
15633                                 payload=parameters,
15634                                 files_=files_,
15635                                 timeout_=timeout_,
15636                                 check_=check_))
15637
15638    def report(
15639        self,
15640        *,
15641        contest_alias: str,
15642        auth_token: Optional[str] = None,
15643        filterBy: Optional[str] = None,
15644        # Out-of-band parameters:
15645        files_: Optional[Mapping[str, BinaryIO]] = None,
15646        check_: bool = True,
15647        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
15648    ) -> ContestReportResponse:
15649        r"""Returns a detailed report of the contest
15650
15651        Args:
15652            contest_alias:
15653            auth_token:
15654            filterBy:
15655
15656        Returns:
15657            The API result object.
15658        """
15659        parameters: Dict[str, str] = {
15660            'contest_alias': contest_alias,
15661        }
15662        if auth_token is not None:
15663            parameters['auth_token'] = auth_token
15664        if filterBy is not None:
15665            parameters['filterBy'] = filterBy
15666        return _OmegaUp_Controllers_Contest__apiReport(
15667            **self._client.query('/api/contest/report/',
15668                                 payload=parameters,
15669                                 files_=files_,
15670                                 timeout_=timeout_,
15671                                 check_=check_))
15672
15673    def role(
15674        self,
15675        *,
15676        contest_alias: str,
15677        token: Optional[str] = None,
15678        # Out-of-band parameters:
15679        files_: Optional[Mapping[str, BinaryIO]] = None,
15680        check_: bool = True,
15681        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
15682    ) -> ContestRoleResponse:
15683        r"""
15684
15685        Args:
15686            contest_alias:
15687            token:
15688
15689        Returns:
15690            The API result object.
15691        """
15692        parameters: Dict[str, str] = {
15693            'contest_alias': contest_alias,
15694        }
15695        if token is not None:
15696            parameters['token'] = token
15697        return _OmegaUp_Controllers_Contest__apiRole(
15698            **self._client.query('/api/contest/role/',
15699                                 payload=parameters,
15700                                 files_=files_,
15701                                 timeout_=timeout_,
15702                                 check_=check_))
15703
15704    def setRecommended(
15705            self,
15706            *,
15707            contest_alias: str,
15708            value: Optional[bool] = None,
15709            # Out-of-band parameters:
15710            files_: Optional[Mapping[str, BinaryIO]] = None,
15711            check_: bool = True,
15712            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
15713        r"""Given a contest_alias, sets the recommended flag on/off.
15714        Only omegaUp admins can call this API.
15715
15716        Args:
15717            contest_alias:
15718            value:
15719
15720        Returns:
15721            The API result object.
15722        """
15723        parameters: Dict[str, str] = {
15724            'contest_alias': contest_alias,
15725        }
15726        if value is not None:
15727            parameters['value'] = str(value)
15728        self._client.query('/api/contest/setRecommended/',
15729                           payload=parameters,
15730                           files_=files_,
15731                           timeout_=timeout_,
15732                           check_=check_)
15733
15734    def contestants(
15735        self,
15736        *,
15737        contest_alias: str,
15738        # Out-of-band parameters:
15739        files_: Optional[Mapping[str, BinaryIO]] = None,
15740        check_: bool = True,
15741        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
15742    ) -> ContestContestantsResponse:
15743        r"""Return users who participate in a contest, as long as contest admin
15744        has chosen to ask for users information and contestants have
15745        previously agreed to share their information.
15746
15747        Args:
15748            contest_alias:
15749
15750        Returns:
15751            The API result object.
15752        """
15753        parameters: Dict[str, str] = {
15754            'contest_alias': contest_alias,
15755        }
15756        return _OmegaUp_Controllers_Contest__apiContestants(
15757            **self._client.query('/api/contest/contestants/',
15758                                 payload=parameters,
15759                                 files_=files_,
15760                                 timeout_=timeout_,
15761                                 check_=check_))
15762
15763    def archive(
15764            self,
15765            *,
15766            contest_alias: str,
15767            archive: Optional[bool] = None,
15768            # Out-of-band parameters:
15769            files_: Optional[Mapping[str, BinaryIO]] = None,
15770            check_: bool = True,
15771            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
15772        r"""Archives or Unarchives a contest if user is the creator
15773
15774        Args:
15775            contest_alias:
15776            archive:
15777
15778        Returns:
15779            The API result object.
15780        """
15781        parameters: Dict[str, str] = {
15782            'contest_alias': contest_alias,
15783        }
15784        if archive is not None:
15785            parameters['archive'] = str(archive)
15786        self._client.query('/api/contest/archive/',
15787                           payload=parameters,
15788                           files_=files_,
15789                           timeout_=timeout_,
15790                           check_=check_)
15791
15792
15793CourseGenerateTokenForCloneCourseResponse = _OmegaUp_Controllers_Course__apiGenerateTokenForCloneCourse
15794"""The return type of the CourseGenerateTokenForCloneCourse API."""
15795
15796CourseCloneResponse = _OmegaUp_Controllers_Course__apiClone
15797"""The return type of the CourseClone API."""
15798
15799CourseGetProblemUsersResponse = _OmegaUp_Controllers_Course__apiGetProblemUsers
15800"""The return type of the CourseGetProblemUsers API."""
15801
15802CourseListAssignmentsResponse = _OmegaUp_Controllers_Course__apiListAssignments
15803"""The return type of the CourseListAssignments API."""
15804
15805CourseRequestsResponse = _OmegaUp_Controllers_Course__apiRequests
15806"""The return type of the CourseRequests API."""
15807
15808CourseListStudentsResponse = _OmegaUp_Controllers_Course__apiListStudents
15809"""The return type of the CourseListStudents API."""
15810
15811CourseStudentProgressResponse = _OmegaUp_Controllers_Course__apiStudentProgress
15812"""The return type of the CourseStudentProgress API."""
15813
15814CourseMyProgressResponse = _OmegaUp_Controllers_Course__apiMyProgress
15815"""The return type of the CourseMyProgress API."""
15816
15817CourseSearchUsersResponse = _OmegaUp_Controllers_Course__apiSearchUsers
15818"""The return type of the CourseSearchUsers API."""
15819
15820CourseAdminsResponse = _OmegaUp_Controllers_Course__apiAdmins
15821"""The return type of the CourseAdmins API."""
15822
15823CourseIntroDetailsResponse = _IntroDetailsPayload
15824"""The return type of the CourseIntroDetails API."""
15825
15826CourseStudentsProgressResponse = _OmegaUp_Controllers_Course__apiStudentsProgress
15827"""The return type of the CourseStudentsProgress API."""
15828
15829CourseAdminDetailsResponse = _CourseDetails
15830"""The return type of the CourseAdminDetails API."""
15831
15832CourseActivityReportResponse = _OmegaUp_Controllers_Course__apiActivityReport
15833"""The return type of the CourseActivityReport API."""
15834
15835CourseAssignmentDetailsResponse = _OmegaUp_Controllers_Course__apiAssignmentDetails
15836"""The return type of the CourseAssignmentDetails API."""
15837
15838CourseRunsResponse = _OmegaUp_Controllers_Course__apiRuns
15839"""The return type of the CourseRuns API."""
15840
15841CourseDetailsResponse = _CourseDetails
15842"""The return type of the CourseDetails API."""
15843
15844CourseClarificationsResponse = _OmegaUp_Controllers_Course__apiClarifications
15845"""The return type of the CourseClarifications API."""
15846
15847CourseProblemClarificationsResponse = _OmegaUp_Controllers_Course__apiProblemClarifications
15848"""The return type of the CourseProblemClarifications API."""
15849
15850CourseAssignmentScoreboardResponse = _Scoreboard
15851"""The return type of the CourseAssignmentScoreboard API."""
15852
15853CourseAssignmentScoreboardEventsResponse = _OmegaUp_Controllers_Course__apiAssignmentScoreboardEvents
15854"""The return type of the CourseAssignmentScoreboardEvents API."""
15855
15856CourseListSolvedProblemsResponse = _OmegaUp_Controllers_Course__apiListSolvedProblems
15857"""The return type of the CourseListSolvedProblems API."""
15858
15859CourseListUnsolvedProblemsResponse = _OmegaUp_Controllers_Course__apiListUnsolvedProblems
15860"""The return type of the CourseListUnsolvedProblems API."""
15861
15862
15863class Course:
15864    r"""CourseController
15865    """
15866    def __init__(self, client: 'Client') -> None:
15867        self._client = client
15868
15869    def generateTokenForCloneCourse(
15870        self,
15871        *,
15872        course_alias: str,
15873        # Out-of-band parameters:
15874        files_: Optional[Mapping[str, BinaryIO]] = None,
15875        check_: bool = True,
15876        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
15877    ) -> CourseGenerateTokenForCloneCourseResponse:
15878        r"""
15879
15880        Args:
15881            course_alias:
15882
15883        Returns:
15884            The API result object.
15885        """
15886        parameters: Dict[str, str] = {
15887            'course_alias': course_alias,
15888        }
15889        return _OmegaUp_Controllers_Course__apiGenerateTokenForCloneCourse(
15890            **self._client.query('/api/course/generateTokenForCloneCourse/',
15891                                 payload=parameters,
15892                                 files_=files_,
15893                                 timeout_=timeout_,
15894                                 check_=check_))
15895
15896    def clone(
15897        self,
15898        *,
15899        alias: str,
15900        course_alias: str,
15901        name: str,
15902        start_time: datetime.datetime,
15903        token: Optional[str] = None,
15904        # Out-of-band parameters:
15905        files_: Optional[Mapping[str, BinaryIO]] = None,
15906        check_: bool = True,
15907        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
15908    ) -> CourseCloneResponse:
15909        r"""Clone a course
15910
15911        Args:
15912            alias:
15913            course_alias:
15914            name:
15915            start_time:
15916            token:
15917
15918        Returns:
15919            The API result object.
15920        """
15921        parameters: Dict[str, str] = {
15922            'alias': alias,
15923            'course_alias': course_alias,
15924            'name': name,
15925            'start_time': str(int(start_time.timestamp())),
15926        }
15927        if token is not None:
15928            parameters['token'] = token
15929        return _OmegaUp_Controllers_Course__apiClone(
15930            **self._client.query('/api/course/clone/',
15931                                 payload=parameters,
15932                                 files_=files_,
15933                                 timeout_=timeout_,
15934                                 check_=check_))
15935
15936    def create(
15937            self,
15938            *,
15939            alias: str,
15940            description: str,
15941            name: str,
15942            start_time: int,
15943            admission_mode: Optional[str] = None,
15944            archived: Optional[bool] = None,
15945            finish_time: Optional[int] = None,
15946            languages: Optional[str] = None,
15947            level: Optional[str] = None,
15948            minimum_progress_for_certificate: Optional[int] = None,
15949            needs_basic_information: Optional[bool] = None,
15950            objective: Optional[str] = None,
15951            requests_user_information: Optional[str] = None,
15952            school_id: Optional[int] = None,
15953            show_scoreboard: Optional[bool] = None,
15954            # Out-of-band parameters:
15955            files_: Optional[Mapping[str, BinaryIO]] = None,
15956            check_: bool = True,
15957            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
15958        r"""Create new course API
15959
15960        Args:
15961            alias:
15962            description:
15963            name:
15964            start_time:
15965            admission_mode:
15966            archived:
15967            finish_time:
15968            languages:
15969            level:
15970            minimum_progress_for_certificate:
15971            needs_basic_information:
15972            objective:
15973            requests_user_information:
15974            school_id:
15975            show_scoreboard:
15976
15977        Returns:
15978            The API result object.
15979        """
15980        parameters: Dict[str, str] = {
15981            'alias': alias,
15982            'description': description,
15983            'name': name,
15984            'start_time': str(start_time),
15985        }
15986        if admission_mode is not None:
15987            parameters['admission_mode'] = admission_mode
15988        if archived is not None:
15989            parameters['archived'] = str(archived)
15990        if finish_time is not None:
15991            parameters['finish_time'] = str(finish_time)
15992        if languages is not None:
15993            parameters['languages'] = languages
15994        if level is not None:
15995            parameters['level'] = level
15996        if minimum_progress_for_certificate is not None:
15997            parameters['minimum_progress_for_certificate'] = str(
15998                minimum_progress_for_certificate)
15999        if needs_basic_information is not None:
16000            parameters['needs_basic_information'] = str(
16001                needs_basic_information)
16002        if objective is not None:
16003            parameters['objective'] = objective
16004        if requests_user_information is not None:
16005            parameters['requests_user_information'] = requests_user_information
16006        if school_id is not None:
16007            parameters['school_id'] = str(school_id)
16008        if show_scoreboard is not None:
16009            parameters['show_scoreboard'] = str(show_scoreboard)
16010        self._client.query('/api/course/create/',
16011                           payload=parameters,
16012                           files_=files_,
16013                           timeout_=timeout_,
16014                           check_=check_)
16015
16016    def createAssignment(
16017            self,
16018            *,
16019            course_alias: str,
16020            alias: Optional[Any] = None,
16021            assignment_type: Optional[Any] = None,
16022            description: Optional[Any] = None,
16023            finish_time: Optional[Any] = None,
16024            name: Optional[Any] = None,
16025            order: Optional[int] = None,
16026            problems: Optional[str] = None,
16027            publish_time_delay: Optional[Any] = None,
16028            start_time: Optional[Any] = None,
16029            unlimited_duration: Optional[bool] = None,
16030            # Out-of-band parameters:
16031            files_: Optional[Mapping[str, BinaryIO]] = None,
16032            check_: bool = True,
16033            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
16034        r"""API to Create an assignment
16035
16036        Args:
16037            course_alias:
16038            alias:
16039            assignment_type:
16040            description:
16041            finish_time:
16042            name:
16043            order:
16044            problems:
16045            publish_time_delay:
16046            start_time:
16047            unlimited_duration:
16048
16049        Returns:
16050            The API result object.
16051        """
16052        parameters: Dict[str, str] = {
16053            'course_alias': course_alias,
16054        }
16055        if alias is not None:
16056            parameters['alias'] = str(alias)
16057        if assignment_type is not None:
16058            parameters['assignment_type'] = str(assignment_type)
16059        if description is not None:
16060            parameters['description'] = str(description)
16061        if finish_time is not None:
16062            parameters['finish_time'] = str(finish_time)
16063        if name is not None:
16064            parameters['name'] = str(name)
16065        if order is not None:
16066            parameters['order'] = str(order)
16067        if problems is not None:
16068            parameters['problems'] = problems
16069        if publish_time_delay is not None:
16070            parameters['publish_time_delay'] = str(publish_time_delay)
16071        if start_time is not None:
16072            parameters['start_time'] = str(start_time)
16073        if unlimited_duration is not None:
16074            parameters['unlimited_duration'] = str(unlimited_duration)
16075        self._client.query('/api/course/createAssignment/',
16076                           payload=parameters,
16077                           files_=files_,
16078                           timeout_=timeout_,
16079                           check_=check_)
16080
16081    def updateAssignment(
16082            self,
16083            *,
16084            assignment: str,
16085            course: str,
16086            finish_time: Optional[datetime.datetime] = None,
16087            start_time: Optional[datetime.datetime] = None,
16088            unlimited_duration: Optional[bool] = None,
16089            # Out-of-band parameters:
16090            files_: Optional[Mapping[str, BinaryIO]] = None,
16091            check_: bool = True,
16092            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
16093        r"""Update an assignment
16094
16095        Args:
16096            assignment:
16097            course:
16098            finish_time:
16099            start_time:
16100            unlimited_duration:
16101
16102        Returns:
16103            The API result object.
16104        """
16105        parameters: Dict[str, str] = {
16106            'assignment': assignment,
16107            'course': course,
16108        }
16109        if finish_time is not None:
16110            parameters['finish_time'] = str(int(finish_time.timestamp()))
16111        if start_time is not None:
16112            parameters['start_time'] = str(int(start_time.timestamp()))
16113        if unlimited_duration is not None:
16114            parameters['unlimited_duration'] = str(unlimited_duration)
16115        self._client.query('/api/course/updateAssignment/',
16116                           payload=parameters,
16117                           files_=files_,
16118                           timeout_=timeout_,
16119                           check_=check_)
16120
16121    def addProblem(
16122            self,
16123            *,
16124            assignment_alias: str,
16125            course_alias: str,
16126            points: float,
16127            problem_alias: str,
16128            commit: Optional[str] = None,
16129            is_extra_problem: Optional[bool] = None,
16130            # Out-of-band parameters:
16131            files_: Optional[Mapping[str, BinaryIO]] = None,
16132            check_: bool = True,
16133            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
16134        r"""Adds a problem to an assignment
16135
16136        Args:
16137            assignment_alias:
16138            course_alias:
16139            points:
16140            problem_alias:
16141            commit:
16142            is_extra_problem:
16143
16144        Returns:
16145            The API result object.
16146        """
16147        parameters: Dict[str, str] = {
16148            'assignment_alias': assignment_alias,
16149            'course_alias': course_alias,
16150            'points': str(points),
16151            'problem_alias': problem_alias,
16152        }
16153        if commit is not None:
16154            parameters['commit'] = commit
16155        if is_extra_problem is not None:
16156            parameters['is_extra_problem'] = str(is_extra_problem)
16157        self._client.query('/api/course/addProblem/',
16158                           payload=parameters,
16159                           files_=files_,
16160                           timeout_=timeout_,
16161                           check_=check_)
16162
16163    def updateProblemsOrder(
16164            self,
16165            *,
16166            assignment_alias: str,
16167            course_alias: str,
16168            problems: str,
16169            # Out-of-band parameters:
16170            files_: Optional[Mapping[str, BinaryIO]] = None,
16171            check_: bool = True,
16172            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
16173        r"""
16174
16175        Args:
16176            assignment_alias:
16177            course_alias:
16178            problems:
16179
16180        Returns:
16181            The API result object.
16182        """
16183        parameters: Dict[str, str] = {
16184            'assignment_alias': assignment_alias,
16185            'course_alias': course_alias,
16186            'problems': problems,
16187        }
16188        self._client.query('/api/course/updateProblemsOrder/',
16189                           payload=parameters,
16190                           files_=files_,
16191                           timeout_=timeout_,
16192                           check_=check_)
16193
16194    def updateAssignmentsOrder(
16195            self,
16196            *,
16197            assignments: str,
16198            course_alias: str,
16199            # Out-of-band parameters:
16200            files_: Optional[Mapping[str, BinaryIO]] = None,
16201            check_: bool = True,
16202            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
16203        r"""
16204
16205        Args:
16206            assignments:
16207            course_alias:
16208
16209        Returns:
16210            The API result object.
16211        """
16212        parameters: Dict[str, str] = {
16213            'assignments': assignments,
16214            'course_alias': course_alias,
16215        }
16216        self._client.query('/api/course/updateAssignmentsOrder/',
16217                           payload=parameters,
16218                           files_=files_,
16219                           timeout_=timeout_,
16220                           check_=check_)
16221
16222    def getProblemUsers(
16223        self,
16224        *,
16225        course_alias: str,
16226        problem_alias: str,
16227        # Out-of-band parameters:
16228        files_: Optional[Mapping[str, BinaryIO]] = None,
16229        check_: bool = True,
16230        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
16231    ) -> CourseGetProblemUsersResponse:
16232        r"""
16233
16234        Args:
16235            course_alias:
16236            problem_alias:
16237
16238        Returns:
16239            The API result object.
16240        """
16241        parameters: Dict[str, str] = {
16242            'course_alias': course_alias,
16243            'problem_alias': problem_alias,
16244        }
16245        return _OmegaUp_Controllers_Course__apiGetProblemUsers(
16246            **self._client.query('/api/course/getProblemUsers/',
16247                                 payload=parameters,
16248                                 files_=files_,
16249                                 timeout_=timeout_,
16250                                 check_=check_))
16251
16252    def removeProblem(
16253            self,
16254            *,
16255            assignment_alias: str,
16256            course_alias: str,
16257            problem_alias: str,
16258            # Out-of-band parameters:
16259            files_: Optional[Mapping[str, BinaryIO]] = None,
16260            check_: bool = True,
16261            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
16262        r"""Remove a problem from an assignment
16263
16264        Args:
16265            assignment_alias:
16266            course_alias:
16267            problem_alias:
16268
16269        Returns:
16270            The API result object.
16271        """
16272        parameters: Dict[str, str] = {
16273            'assignment_alias': assignment_alias,
16274            'course_alias': course_alias,
16275            'problem_alias': problem_alias,
16276        }
16277        self._client.query('/api/course/removeProblem/',
16278                           payload=parameters,
16279                           files_=files_,
16280                           timeout_=timeout_,
16281                           check_=check_)
16282
16283    def listAssignments(
16284        self,
16285        *,
16286        course_alias: str,
16287        # Out-of-band parameters:
16288        files_: Optional[Mapping[str, BinaryIO]] = None,
16289        check_: bool = True,
16290        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
16291    ) -> CourseListAssignmentsResponse:
16292        r"""List course assignments
16293
16294        Args:
16295            course_alias:
16296
16297        Returns:
16298            The API result object.
16299        """
16300        parameters: Dict[str, str] = {
16301            'course_alias': course_alias,
16302        }
16303        return _OmegaUp_Controllers_Course__apiListAssignments(
16304            **self._client.query('/api/course/listAssignments/',
16305                                 payload=parameters,
16306                                 files_=files_,
16307                                 timeout_=timeout_,
16308                                 check_=check_))
16309
16310    def removeAssignment(
16311            self,
16312            *,
16313            assignment_alias: str,
16314            course_alias: str,
16315            # Out-of-band parameters:
16316            files_: Optional[Mapping[str, BinaryIO]] = None,
16317            check_: bool = True,
16318            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
16319        r"""Remove an assignment from a course
16320
16321        Args:
16322            assignment_alias:
16323            course_alias:
16324
16325        Returns:
16326            The API result object.
16327        """
16328        parameters: Dict[str, str] = {
16329            'assignment_alias': assignment_alias,
16330            'course_alias': course_alias,
16331        }
16332        self._client.query('/api/course/removeAssignment/',
16333                           payload=parameters,
16334                           files_=files_,
16335                           timeout_=timeout_,
16336                           check_=check_)
16337
16338    def requests(
16339        self,
16340        *,
16341        course_alias: str,
16342        # Out-of-band parameters:
16343        files_: Optional[Mapping[str, BinaryIO]] = None,
16344        check_: bool = True,
16345        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
16346    ) -> CourseRequestsResponse:
16347        r"""Returns the list of requests made by participants who are interested to
16348        join the course
16349
16350        Args:
16351            course_alias:
16352
16353        Returns:
16354            The API result object.
16355        """
16356        parameters: Dict[str, str] = {
16357            'course_alias': course_alias,
16358        }
16359        return _OmegaUp_Controllers_Course__apiRequests(
16360            **self._client.query('/api/course/requests/',
16361                                 payload=parameters,
16362                                 files_=files_,
16363                                 timeout_=timeout_,
16364                                 check_=check_))
16365
16366    def arbitrateRequest(
16367            self,
16368            *,
16369            course_alias: str,
16370            resolution: bool,
16371            username: str,
16372            # Out-of-band parameters:
16373            files_: Optional[Mapping[str, BinaryIO]] = None,
16374            check_: bool = True,
16375            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
16376        r"""Stores the resolution given to a certain request made by a contestant
16377        interested to join the course.
16378
16379        Args:
16380            course_alias:
16381            resolution:
16382            username:
16383
16384        Returns:
16385            The API result object.
16386        """
16387        parameters: Dict[str, str] = {
16388            'course_alias': course_alias,
16389            'resolution': str(resolution),
16390            'username': username,
16391        }
16392        self._client.query('/api/course/arbitrateRequest/',
16393                           payload=parameters,
16394                           files_=files_,
16395                           timeout_=timeout_,
16396                           check_=check_)
16397
16398    def listStudents(
16399        self,
16400        *,
16401        course_alias: str,
16402        # Out-of-band parameters:
16403        files_: Optional[Mapping[str, BinaryIO]] = None,
16404        check_: bool = True,
16405        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
16406    ) -> CourseListStudentsResponse:
16407        r"""List students in a course
16408
16409        Args:
16410            course_alias:
16411
16412        Returns:
16413            The API result object.
16414        """
16415        parameters: Dict[str, str] = {
16416            'course_alias': course_alias,
16417        }
16418        return _OmegaUp_Controllers_Course__apiListStudents(
16419            **self._client.query('/api/course/listStudents/',
16420                                 payload=parameters,
16421                                 files_=files_,
16422                                 timeout_=timeout_,
16423                                 check_=check_))
16424
16425    def studentProgress(
16426        self,
16427        *,
16428        assignment_alias: str,
16429        course_alias: str,
16430        usernameOrEmail: str,
16431        # Out-of-band parameters:
16432        files_: Optional[Mapping[str, BinaryIO]] = None,
16433        check_: bool = True,
16434        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
16435    ) -> CourseStudentProgressResponse:
16436        r"""
16437
16438        Args:
16439            assignment_alias:
16440            course_alias:
16441            usernameOrEmail:
16442
16443        Returns:
16444            The API result object.
16445        """
16446        parameters: Dict[str, str] = {
16447            'assignment_alias': assignment_alias,
16448            'course_alias': course_alias,
16449            'usernameOrEmail': usernameOrEmail,
16450        }
16451        return _OmegaUp_Controllers_Course__apiStudentProgress(
16452            **self._client.query('/api/course/studentProgress/',
16453                                 payload=parameters,
16454                                 files_=files_,
16455                                 timeout_=timeout_,
16456                                 check_=check_))
16457
16458    def myProgress(
16459        self,
16460        *,
16461        alias: str,
16462        # Out-of-band parameters:
16463        files_: Optional[Mapping[str, BinaryIO]] = None,
16464        check_: bool = True,
16465        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
16466    ) -> CourseMyProgressResponse:
16467        r"""Returns details of a given course
16468
16469        Args:
16470            alias:
16471
16472        Returns:
16473            The API result object.
16474        """
16475        parameters: Dict[str, str] = {
16476            'alias': alias,
16477        }
16478        return _OmegaUp_Controllers_Course__apiMyProgress(
16479            **self._client.query('/api/course/myProgress/',
16480                                 payload=parameters,
16481                                 files_=files_,
16482                                 timeout_=timeout_,
16483                                 check_=check_))
16484
16485    def addStudent(
16486            self,
16487            *,
16488            accept_teacher_git_object_id: str,
16489            course_alias: str,
16490            privacy_git_object_id: str,
16491            share_user_information: bool,
16492            statement_type: str,
16493            usernameOrEmail: str,
16494            accept_teacher: Optional[bool] = None,
16495            # Out-of-band parameters:
16496            files_: Optional[Mapping[str, BinaryIO]] = None,
16497            check_: bool = True,
16498            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
16499        r"""Add Student to Course.
16500
16501        Args:
16502            accept_teacher_git_object_id:
16503            course_alias:
16504            privacy_git_object_id:
16505            share_user_information:
16506            statement_type:
16507            usernameOrEmail:
16508            accept_teacher:
16509
16510        Returns:
16511            The API result object.
16512        """
16513        parameters: Dict[str, str] = {
16514            'accept_teacher_git_object_id': accept_teacher_git_object_id,
16515            'course_alias': course_alias,
16516            'privacy_git_object_id': privacy_git_object_id,
16517            'share_user_information': str(share_user_information),
16518            'statement_type': statement_type,
16519            'usernameOrEmail': usernameOrEmail,
16520        }
16521        if accept_teacher is not None:
16522            parameters['accept_teacher'] = str(accept_teacher)
16523        self._client.query('/api/course/addStudent/',
16524                           payload=parameters,
16525                           files_=files_,
16526                           timeout_=timeout_,
16527                           check_=check_)
16528
16529    def removeStudent(
16530            self,
16531            *,
16532            course_alias: str,
16533            usernameOrEmail: str,
16534            # Out-of-band parameters:
16535            files_: Optional[Mapping[str, BinaryIO]] = None,
16536            check_: bool = True,
16537            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
16538        r"""Remove Student from Course
16539
16540        Args:
16541            course_alias:
16542            usernameOrEmail:
16543
16544        Returns:
16545            The API result object.
16546        """
16547        parameters: Dict[str, str] = {
16548            'course_alias': course_alias,
16549            'usernameOrEmail': usernameOrEmail,
16550        }
16551        self._client.query('/api/course/removeStudent/',
16552                           payload=parameters,
16553                           files_=files_,
16554                           timeout_=timeout_,
16555                           check_=check_)
16556
16557    def searchUsers(
16558        self,
16559        *,
16560        assignment_alias: str,
16561        course_alias: str,
16562        query: Optional[str] = None,
16563        # Out-of-band parameters:
16564        files_: Optional[Mapping[str, BinaryIO]] = None,
16565        check_: bool = True,
16566        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
16567    ) -> CourseSearchUsersResponse:
16568        r"""Search users in course assignment
16569
16570        Args:
16571            assignment_alias:
16572            course_alias:
16573            query:
16574
16575        Returns:
16576            The API result object.
16577        """
16578        parameters: Dict[str, str] = {
16579            'assignment_alias': assignment_alias,
16580            'course_alias': course_alias,
16581        }
16582        if query is not None:
16583            parameters['query'] = query
16584        return _OmegaUp_Controllers_Course__apiSearchUsers(
16585            **self._client.query('/api/course/searchUsers/',
16586                                 payload=parameters,
16587                                 files_=files_,
16588                                 timeout_=timeout_,
16589                                 check_=check_))
16590
16591    def admins(
16592        self,
16593        *,
16594        course_alias: str,
16595        # Out-of-band parameters:
16596        files_: Optional[Mapping[str, BinaryIO]] = None,
16597        check_: bool = True,
16598        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
16599    ) -> CourseAdminsResponse:
16600        r"""Returns all course administrators
16601
16602        Args:
16603            course_alias:
16604
16605        Returns:
16606            The API result object.
16607        """
16608        parameters: Dict[str, str] = {
16609            'course_alias': course_alias,
16610        }
16611        return _OmegaUp_Controllers_Course__apiAdmins(
16612            **self._client.query('/api/course/admins/',
16613                                 payload=parameters,
16614                                 files_=files_,
16615                                 timeout_=timeout_,
16616                                 check_=check_))
16617
16618    def addAdmin(
16619            self,
16620            *,
16621            course_alias: str,
16622            usernameOrEmail: str,
16623            # Out-of-band parameters:
16624            files_: Optional[Mapping[str, BinaryIO]] = None,
16625            check_: bool = True,
16626            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
16627        r"""Adds an admin to a course
16628
16629        Args:
16630            course_alias:
16631            usernameOrEmail:
16632
16633        Returns:
16634            The API result object.
16635        """
16636        parameters: Dict[str, str] = {
16637            'course_alias': course_alias,
16638            'usernameOrEmail': usernameOrEmail,
16639        }
16640        self._client.query('/api/course/addAdmin/',
16641                           payload=parameters,
16642                           files_=files_,
16643                           timeout_=timeout_,
16644                           check_=check_)
16645
16646    def removeAdmin(
16647            self,
16648            *,
16649            course_alias: str,
16650            usernameOrEmail: str,
16651            # Out-of-band parameters:
16652            files_: Optional[Mapping[str, BinaryIO]] = None,
16653            check_: bool = True,
16654            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
16655        r"""Removes an admin from a course
16656
16657        Args:
16658            course_alias:
16659            usernameOrEmail:
16660
16661        Returns:
16662            The API result object.
16663        """
16664        parameters: Dict[str, str] = {
16665            'course_alias': course_alias,
16666            'usernameOrEmail': usernameOrEmail,
16667        }
16668        self._client.query('/api/course/removeAdmin/',
16669                           payload=parameters,
16670                           files_=files_,
16671                           timeout_=timeout_,
16672                           check_=check_)
16673
16674    def addGroupAdmin(
16675            self,
16676            *,
16677            course_alias: str,
16678            group: str,
16679            # Out-of-band parameters:
16680            files_: Optional[Mapping[str, BinaryIO]] = None,
16681            check_: bool = True,
16682            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
16683        r"""Adds an group admin to a course
16684
16685        Args:
16686            course_alias:
16687            group:
16688
16689        Returns:
16690            The API result object.
16691        """
16692        parameters: Dict[str, str] = {
16693            'course_alias': course_alias,
16694            'group': group,
16695        }
16696        self._client.query('/api/course/addGroupAdmin/',
16697                           payload=parameters,
16698                           files_=files_,
16699                           timeout_=timeout_,
16700                           check_=check_)
16701
16702    def removeGroupAdmin(
16703            self,
16704            *,
16705            course_alias: str,
16706            group: str,
16707            # Out-of-band parameters:
16708            files_: Optional[Mapping[str, BinaryIO]] = None,
16709            check_: bool = True,
16710            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
16711        r"""Removes a group admin from a course
16712
16713        Args:
16714            course_alias:
16715            group:
16716
16717        Returns:
16718            The API result object.
16719        """
16720        parameters: Dict[str, str] = {
16721            'course_alias': course_alias,
16722            'group': group,
16723        }
16724        self._client.query('/api/course/removeGroupAdmin/',
16725                           payload=parameters,
16726                           files_=files_,
16727                           timeout_=timeout_,
16728                           check_=check_)
16729
16730    def addTeachingAssistant(
16731            self,
16732            *,
16733            course_alias: str,
16734            usernameOrEmail: str,
16735            # Out-of-band parameters:
16736            files_: Optional[Mapping[str, BinaryIO]] = None,
16737            check_: bool = True,
16738            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
16739        r"""Adds a teaching assistant to a course
16740
16741        Args:
16742            course_alias:
16743            usernameOrEmail:
16744
16745        Returns:
16746            The API result object.
16747        """
16748        parameters: Dict[str, str] = {
16749            'course_alias': course_alias,
16750            'usernameOrEmail': usernameOrEmail,
16751        }
16752        self._client.query('/api/course/addTeachingAssistant/',
16753                           payload=parameters,
16754                           files_=files_,
16755                           timeout_=timeout_,
16756                           check_=check_)
16757
16758    def addGroupTeachingAssistant(
16759            self,
16760            *,
16761            course_alias: str,
16762            group: str,
16763            # Out-of-band parameters:
16764            files_: Optional[Mapping[str, BinaryIO]] = None,
16765            check_: bool = True,
16766            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
16767        r"""Adds an group teaching assistant to a course
16768
16769        Args:
16770            course_alias:
16771            group:
16772
16773        Returns:
16774            The API result object.
16775        """
16776        parameters: Dict[str, str] = {
16777            'course_alias': course_alias,
16778            'group': group,
16779        }
16780        self._client.query('/api/course/addGroupTeachingAssistant/',
16781                           payload=parameters,
16782                           files_=files_,
16783                           timeout_=timeout_,
16784                           check_=check_)
16785
16786    def removeGroupTeachingAssistant(
16787            self,
16788            *,
16789            course_alias: str,
16790            group: str,
16791            # Out-of-band parameters:
16792            files_: Optional[Mapping[str, BinaryIO]] = None,
16793            check_: bool = True,
16794            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
16795        r"""Removes a group teaching assistant from a course
16796
16797        Args:
16798            course_alias:
16799            group:
16800
16801        Returns:
16802            The API result object.
16803        """
16804        parameters: Dict[str, str] = {
16805            'course_alias': course_alias,
16806            'group': group,
16807        }
16808        self._client.query('/api/course/removeGroupTeachingAssistant/',
16809                           payload=parameters,
16810                           files_=files_,
16811                           timeout_=timeout_,
16812                           check_=check_)
16813
16814    def removeTeachingAssistant(
16815            self,
16816            *,
16817            course_alias: str,
16818            usernameOrEmail: str,
16819            # Out-of-band parameters:
16820            files_: Optional[Mapping[str, BinaryIO]] = None,
16821            check_: bool = True,
16822            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
16823        r"""Removes a teaching assistant from a course
16824
16825        Args:
16826            course_alias:
16827            usernameOrEmail:
16828
16829        Returns:
16830            The API result object.
16831        """
16832        parameters: Dict[str, str] = {
16833            'course_alias': course_alias,
16834            'usernameOrEmail': usernameOrEmail,
16835        }
16836        self._client.query('/api/course/removeTeachingAssistant/',
16837                           payload=parameters,
16838                           files_=files_,
16839                           timeout_=timeout_,
16840                           check_=check_)
16841
16842    def requestFeedback(
16843            self,
16844            *,
16845            assignment_alias: str,
16846            course_alias: str,
16847            guid: str,
16848            # Out-of-band parameters:
16849            files_: Optional[Mapping[str, BinaryIO]] = None,
16850            check_: bool = True,
16851            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
16852        r"""Request feedback
16853
16854        Args:
16855            assignment_alias:
16856            course_alias:
16857            guid:
16858
16859        Returns:
16860            The API result object.
16861        """
16862        parameters: Dict[str, str] = {
16863            'assignment_alias': assignment_alias,
16864            'course_alias': course_alias,
16865            'guid': guid,
16866        }
16867        self._client.query('/api/course/requestFeedback/',
16868                           payload=parameters,
16869                           files_=files_,
16870                           timeout_=timeout_,
16871                           check_=check_)
16872
16873    def introDetails(
16874        self,
16875        *,
16876        course_alias: str,
16877        # Out-of-band parameters:
16878        files_: Optional[Mapping[str, BinaryIO]] = None,
16879        check_: bool = True,
16880        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
16881    ) -> CourseIntroDetailsResponse:
16882        r"""Show course intro only on public courses when user is not yet registered
16883
16884        Args:
16885            course_alias:
16886
16887        Returns:
16888            The API result object.
16889        """
16890        parameters: Dict[str, str] = {
16891            'course_alias': course_alias,
16892        }
16893        return _IntroDetailsPayload(
16894            **self._client.query('/api/course/introDetails/',
16895                                 payload=parameters,
16896                                 files_=files_,
16897                                 timeout_=timeout_,
16898                                 check_=check_))
16899
16900    def studentsProgress(
16901        self,
16902        *,
16903        course: str,
16904        length: int,
16905        page: int,
16906        # Out-of-band parameters:
16907        files_: Optional[Mapping[str, BinaryIO]] = None,
16908        check_: bool = True,
16909        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
16910    ) -> CourseStudentsProgressResponse:
16911        r"""
16912
16913        Args:
16914            course:
16915            length:
16916            page:
16917
16918        Returns:
16919            The API result object.
16920        """
16921        parameters: Dict[str, str] = {
16922            'course': course,
16923            'length': str(length),
16924            'page': str(page),
16925        }
16926        return _OmegaUp_Controllers_Course__apiStudentsProgress(
16927            **self._client.query('/api/course/studentsProgress/',
16928                                 payload=parameters,
16929                                 files_=files_,
16930                                 timeout_=timeout_,
16931                                 check_=check_))
16932
16933    def registerForCourse(
16934            self,
16935            *,
16936            course_alias: str,
16937            accept_teacher: Optional[bool] = None,
16938            share_user_information: Optional[bool] = None,
16939            # Out-of-band parameters:
16940            files_: Optional[Mapping[str, BinaryIO]] = None,
16941            check_: bool = True,
16942            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
16943        r"""
16944
16945        Args:
16946            course_alias:
16947            accept_teacher:
16948            share_user_information:
16949
16950        Returns:
16951            The API result object.
16952        """
16953        parameters: Dict[str, str] = {
16954            'course_alias': course_alias,
16955        }
16956        if accept_teacher is not None:
16957            parameters['accept_teacher'] = str(accept_teacher)
16958        if share_user_information is not None:
16959            parameters['share_user_information'] = str(share_user_information)
16960        self._client.query('/api/course/registerForCourse/',
16961                           payload=parameters,
16962                           files_=files_,
16963                           timeout_=timeout_,
16964                           check_=check_)
16965
16966    def adminDetails(
16967        self,
16968        *,
16969        alias: str,
16970        # Out-of-band parameters:
16971        files_: Optional[Mapping[str, BinaryIO]] = None,
16972        check_: bool = True,
16973        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
16974    ) -> CourseAdminDetailsResponse:
16975        r"""Returns all details of a given Course
16976
16977        Args:
16978            alias:
16979
16980        Returns:
16981            The API result object.
16982        """
16983        parameters: Dict[str, str] = {
16984            'alias': alias,
16985        }
16986        return _CourseDetails(**self._client.query('/api/course/adminDetails/',
16987                                                   payload=parameters,
16988                                                   files_=files_,
16989                                                   timeout_=timeout_,
16990                                                   check_=check_))
16991
16992    def activityReport(
16993        self,
16994        *,
16995        course_alias: str,
16996        length: Optional[int] = None,
16997        page: Optional[int] = None,
16998        # Out-of-band parameters:
16999        files_: Optional[Mapping[str, BinaryIO]] = None,
17000        check_: bool = True,
17001        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
17002    ) -> CourseActivityReportResponse:
17003        r"""Returns a report with all user activity for a course.
17004
17005        Args:
17006            course_alias:
17007            length:
17008            page:
17009
17010        Returns:
17011            The API result object.
17012        """
17013        parameters: Dict[str, str] = {
17014            'course_alias': course_alias,
17015        }
17016        if length is not None:
17017            parameters['length'] = str(length)
17018        if page is not None:
17019            parameters['page'] = str(page)
17020        return _OmegaUp_Controllers_Course__apiActivityReport(
17021            **self._client.query('/api/course/activityReport/',
17022                                 payload=parameters,
17023                                 files_=files_,
17024                                 timeout_=timeout_,
17025                                 check_=check_))
17026
17027    def archive(
17028            self,
17029            *,
17030            archive: bool,
17031            course_alias: str,
17032            # Out-of-band parameters:
17033            files_: Optional[Mapping[str, BinaryIO]] = None,
17034            check_: bool = True,
17035            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
17036        r"""Archives or un-archives a course
17037
17038        Args:
17039            archive:
17040            course_alias:
17041
17042        Returns:
17043            The API result object.
17044        """
17045        parameters: Dict[str, str] = {
17046            'archive': str(archive),
17047            'course_alias': course_alias,
17048        }
17049        self._client.query('/api/course/archive/',
17050                           payload=parameters,
17051                           files_=files_,
17052                           timeout_=timeout_,
17053                           check_=check_)
17054
17055    def assignmentDetails(
17056        self,
17057        *,
17058        assignment: str,
17059        course: str,
17060        token: Optional[str] = None,
17061        # Out-of-band parameters:
17062        files_: Optional[Mapping[str, BinaryIO]] = None,
17063        check_: bool = True,
17064        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
17065    ) -> CourseAssignmentDetailsResponse:
17066        r"""Returns details of a given assignment
17067
17068        Args:
17069            assignment:
17070            course:
17071            token:
17072
17073        Returns:
17074            The API result object.
17075        """
17076        parameters: Dict[str, str] = {
17077            'assignment': assignment,
17078            'course': course,
17079        }
17080        if token is not None:
17081            parameters['token'] = token
17082        return _OmegaUp_Controllers_Course__apiAssignmentDetails(
17083            **self._client.query('/api/course/assignmentDetails/',
17084                                 payload=parameters,
17085                                 files_=files_,
17086                                 timeout_=timeout_,
17087                                 check_=check_))
17088
17089    def runs(
17090            self,
17091            *,
17092            assignment_alias: str,
17093            course_alias: str,
17094            language: Optional[str] = None,
17095            offset: Optional[int] = None,
17096            problem_alias: Optional[str] = None,
17097            rowcount: Optional[int] = None,
17098            status: Optional[str] = None,
17099            username: Optional[str] = None,
17100            verdict: Optional[str] = None,
17101            # Out-of-band parameters:
17102            files_: Optional[Mapping[str, BinaryIO]] = None,
17103            check_: bool = True,
17104            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
17105    ) -> CourseRunsResponse:
17106        r"""Returns all runs for a course
17107
17108        Args:
17109            assignment_alias:
17110            course_alias:
17111            language:
17112            offset:
17113            problem_alias:
17114            rowcount:
17115            status:
17116            username:
17117            verdict:
17118
17119        Returns:
17120            The API result object.
17121        """
17122        parameters: Dict[str, str] = {
17123            'assignment_alias': assignment_alias,
17124            'course_alias': course_alias,
17125        }
17126        if language is not None:
17127            parameters['language'] = language
17128        if offset is not None:
17129            parameters['offset'] = str(offset)
17130        if problem_alias is not None:
17131            parameters['problem_alias'] = problem_alias
17132        if rowcount is not None:
17133            parameters['rowcount'] = str(rowcount)
17134        if status is not None:
17135            parameters['status'] = status
17136        if username is not None:
17137            parameters['username'] = username
17138        if verdict is not None:
17139            parameters['verdict'] = verdict
17140        return _OmegaUp_Controllers_Course__apiRuns(
17141            **self._client.query('/api/course/runs/',
17142                                 payload=parameters,
17143                                 files_=files_,
17144                                 timeout_=timeout_,
17145                                 check_=check_))
17146
17147    def details(
17148        self,
17149        *,
17150        alias: str,
17151        # Out-of-band parameters:
17152        files_: Optional[Mapping[str, BinaryIO]] = None,
17153        check_: bool = True,
17154        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
17155    ) -> CourseDetailsResponse:
17156        r"""Returns details of a given course
17157
17158        Args:
17159            alias:
17160
17161        Returns:
17162            The API result object.
17163        """
17164        parameters: Dict[str, str] = {
17165            'alias': alias,
17166        }
17167        return _CourseDetails(**self._client.query('/api/course/details/',
17168                                                   payload=parameters,
17169                                                   files_=files_,
17170                                                   timeout_=timeout_,
17171                                                   check_=check_))
17172
17173    def update(
17174            self,
17175            *,
17176            alias: str,
17177            languages: str,
17178            school_id: int,
17179            admission_mode: Optional[str] = None,
17180            description: Optional[str] = None,
17181            finish_time: Optional[datetime.datetime] = None,
17182            level: Optional[str] = None,
17183            name: Optional[str] = None,
17184            needs_basic_information: Optional[bool] = None,
17185            objective: Optional[str] = None,
17186            requests_user_information: Optional[str] = None,
17187            show_scoreboard: Optional[bool] = None,
17188            start_time: Optional[datetime.datetime] = None,
17189            unlimited_duration: Optional[bool] = None,
17190            # Out-of-band parameters:
17191            files_: Optional[Mapping[str, BinaryIO]] = None,
17192            check_: bool = True,
17193            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
17194        r"""Edit Course contents
17195
17196        Args:
17197            alias:
17198            languages:
17199            school_id:
17200            admission_mode:
17201            description:
17202            finish_time:
17203            level:
17204            name:
17205            needs_basic_information:
17206            objective:
17207            requests_user_information:
17208            show_scoreboard:
17209            start_time:
17210            unlimited_duration:
17211
17212        Returns:
17213            The API result object.
17214        """
17215        parameters: Dict[str, str] = {
17216            'alias': alias,
17217            'languages': languages,
17218            'school_id': str(school_id),
17219        }
17220        if admission_mode is not None:
17221            parameters['admission_mode'] = admission_mode
17222        if description is not None:
17223            parameters['description'] = description
17224        if finish_time is not None:
17225            parameters['finish_time'] = str(int(finish_time.timestamp()))
17226        if level is not None:
17227            parameters['level'] = level
17228        if name is not None:
17229            parameters['name'] = name
17230        if needs_basic_information is not None:
17231            parameters['needs_basic_information'] = str(
17232                needs_basic_information)
17233        if objective is not None:
17234            parameters['objective'] = objective
17235        if requests_user_information is not None:
17236            parameters['requests_user_information'] = requests_user_information
17237        if show_scoreboard is not None:
17238            parameters['show_scoreboard'] = str(show_scoreboard)
17239        if start_time is not None:
17240            parameters['start_time'] = str(int(start_time.timestamp()))
17241        if unlimited_duration is not None:
17242            parameters['unlimited_duration'] = str(unlimited_duration)
17243        self._client.query('/api/course/update/',
17244                           payload=parameters,
17245                           files_=files_,
17246                           timeout_=timeout_,
17247                           check_=check_)
17248
17249    def clarifications(
17250        self,
17251        *,
17252        course_alias: str,
17253        offset: int,
17254        rowcount: int,
17255        # Out-of-band parameters:
17256        files_: Optional[Mapping[str, BinaryIO]] = None,
17257        check_: bool = True,
17258        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
17259    ) -> CourseClarificationsResponse:
17260        r"""Gets the clarifications of all assignments in a course
17261
17262        Args:
17263            course_alias:
17264            offset:
17265            rowcount:
17266
17267        Returns:
17268            The API result object.
17269        """
17270        parameters: Dict[str, str] = {
17271            'course_alias': course_alias,
17272            'offset': str(offset),
17273            'rowcount': str(rowcount),
17274        }
17275        return _OmegaUp_Controllers_Course__apiClarifications(
17276            **self._client.query('/api/course/clarifications/',
17277                                 payload=parameters,
17278                                 files_=files_,
17279                                 timeout_=timeout_,
17280                                 check_=check_))
17281
17282    def problemClarifications(
17283        self,
17284        *,
17285        assignment_alias: str,
17286        course_alias: str,
17287        offset: int,
17288        problem_alias: str,
17289        rowcount: int,
17290        # Out-of-band parameters:
17291        files_: Optional[Mapping[str, BinaryIO]] = None,
17292        check_: bool = True,
17293        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
17294    ) -> CourseProblemClarificationsResponse:
17295        r"""Get clarifications of problem in a contest
17296
17297        Args:
17298            assignment_alias:
17299            course_alias:
17300            offset:
17301            problem_alias:
17302            rowcount:
17303
17304        Returns:
17305            The API result object.
17306        """
17307        parameters: Dict[str, str] = {
17308            'assignment_alias': assignment_alias,
17309            'course_alias': course_alias,
17310            'offset': str(offset),
17311            'problem_alias': problem_alias,
17312            'rowcount': str(rowcount),
17313        }
17314        return _OmegaUp_Controllers_Course__apiProblemClarifications(
17315            **self._client.query('/api/course/problemClarifications/',
17316                                 payload=parameters,
17317                                 files_=files_,
17318                                 timeout_=timeout_,
17319                                 check_=check_))
17320
17321    def assignmentScoreboard(
17322        self,
17323        *,
17324        assignment: str,
17325        course: str,
17326        token: Optional[str] = None,
17327        # Out-of-band parameters:
17328        files_: Optional[Mapping[str, BinaryIO]] = None,
17329        check_: bool = True,
17330        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
17331    ) -> CourseAssignmentScoreboardResponse:
17332        r"""Gets Scoreboard for an assignment
17333
17334        Args:
17335            assignment:
17336            course:
17337            token:
17338
17339        Returns:
17340            The API result object.
17341        """
17342        parameters: Dict[str, str] = {
17343            'assignment': assignment,
17344            'course': course,
17345        }
17346        if token is not None:
17347            parameters['token'] = token
17348        return _Scoreboard(
17349            **self._client.query('/api/course/assignmentScoreboard/',
17350                                 payload=parameters,
17351                                 files_=files_,
17352                                 timeout_=timeout_,
17353                                 check_=check_))
17354
17355    def assignmentScoreboardEvents(
17356        self,
17357        *,
17358        assignment: str,
17359        course: str,
17360        token: Optional[str] = None,
17361        # Out-of-band parameters:
17362        files_: Optional[Mapping[str, BinaryIO]] = None,
17363        check_: bool = True,
17364        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
17365    ) -> CourseAssignmentScoreboardEventsResponse:
17366        r"""Returns the Scoreboard events
17367
17368        Args:
17369            assignment:
17370            course:
17371            token:
17372
17373        Returns:
17374            The API result object.
17375        """
17376        parameters: Dict[str, str] = {
17377            'assignment': assignment,
17378            'course': course,
17379        }
17380        if token is not None:
17381            parameters['token'] = token
17382        return _OmegaUp_Controllers_Course__apiAssignmentScoreboardEvents(
17383            **self._client.query('/api/course/assignmentScoreboardEvents/',
17384                                 payload=parameters,
17385                                 files_=files_,
17386                                 timeout_=timeout_,
17387                                 check_=check_))
17388
17389    def listSolvedProblems(
17390        self,
17391        *,
17392        course_alias: str,
17393        # Out-of-band parameters:
17394        files_: Optional[Mapping[str, BinaryIO]] = None,
17395        check_: bool = True,
17396        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
17397    ) -> CourseListSolvedProblemsResponse:
17398        r"""Get Problems solved by users of a course
17399
17400        Args:
17401            course_alias:
17402
17403        Returns:
17404            The API result object.
17405        """
17406        parameters: Dict[str, str] = {
17407            'course_alias': course_alias,
17408        }
17409        return _OmegaUp_Controllers_Course__apiListSolvedProblems(
17410            **self._client.query('/api/course/listSolvedProblems/',
17411                                 payload=parameters,
17412                                 files_=files_,
17413                                 timeout_=timeout_,
17414                                 check_=check_))
17415
17416    def listUnsolvedProblems(
17417        self,
17418        *,
17419        course_alias: str,
17420        # Out-of-band parameters:
17421        files_: Optional[Mapping[str, BinaryIO]] = None,
17422        check_: bool = True,
17423        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
17424    ) -> CourseListUnsolvedProblemsResponse:
17425        r"""Get Problems unsolved by users of a course
17426
17427        Args:
17428            course_alias:
17429
17430        Returns:
17431            The API result object.
17432        """
17433        parameters: Dict[str, str] = {
17434            'course_alias': course_alias,
17435        }
17436        return _OmegaUp_Controllers_Course__apiListUnsolvedProblems(
17437            **self._client.query('/api/course/listUnsolvedProblems/',
17438                                 payload=parameters,
17439                                 files_=files_,
17440                                 timeout_=timeout_,
17441                                 check_=check_))
17442
17443
17444GraderStatusResponse = _OmegaUp_Controllers_Grader__apiStatus
17445"""The return type of the GraderStatus API."""
17446
17447
17448class Grader:
17449    r"""Description of GraderController
17450    """
17451    def __init__(self, client: 'Client') -> None:
17452        self._client = client
17453
17454    def status(
17455        self,
17456        *,
17457        # Out-of-band parameters:
17458        files_: Optional[Mapping[str, BinaryIO]] = None,
17459        check_: bool = True,
17460        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
17461    ) -> GraderStatusResponse:
17462        r"""Calls to /status grader
17463
17464        Returns:
17465            The API result object.
17466        """
17467        parameters: Dict[str, str] = {}
17468        return _OmegaUp_Controllers_Grader__apiStatus(
17469            **self._client.query('/api/grader/status/',
17470                                 payload=parameters,
17471                                 files_=files_,
17472                                 timeout_=timeout_,
17473                                 check_=check_))
17474
17475
17476GroupMyListResponse = _OmegaUp_Controllers_Group__apiMyList
17477"""The return type of the GroupMyList API."""
17478
17479GroupListResponse = Sequence['_GroupListItem']
17480"""The return type of the GroupList API."""
17481
17482GroupDetailsResponse = _OmegaUp_Controllers_Group__apiDetails
17483"""The return type of the GroupDetails API."""
17484
17485GroupMembersResponse = _OmegaUp_Controllers_Group__apiMembers
17486"""The return type of the GroupMembers API."""
17487
17488
17489class Group:
17490    r"""GroupController
17491    """
17492    def __init__(self, client: 'Client') -> None:
17493        self._client = client
17494
17495    def create(
17496            self,
17497            *,
17498            alias: str,
17499            description: str,
17500            name: str,
17501            # Out-of-band parameters:
17502            files_: Optional[Mapping[str, BinaryIO]] = None,
17503            check_: bool = True,
17504            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
17505        r"""New group
17506
17507        Args:
17508            alias:
17509            description:
17510            name:
17511
17512        Returns:
17513            The API result object.
17514        """
17515        parameters: Dict[str, str] = {
17516            'alias': alias,
17517            'description': description,
17518            'name': name,
17519        }
17520        self._client.query('/api/group/create/',
17521                           payload=parameters,
17522                           files_=files_,
17523                           timeout_=timeout_,
17524                           check_=check_)
17525
17526    def update(
17527            self,
17528            *,
17529            alias: str,
17530            description: str,
17531            name: str,
17532            # Out-of-band parameters:
17533            files_: Optional[Mapping[str, BinaryIO]] = None,
17534            check_: bool = True,
17535            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
17536        r"""Update an existing group
17537
17538        Args:
17539            alias:
17540            description:
17541            name:
17542
17543        Returns:
17544            The API result object.
17545        """
17546        parameters: Dict[str, str] = {
17547            'alias': alias,
17548            'description': description,
17549            'name': name,
17550        }
17551        self._client.query('/api/group/update/',
17552                           payload=parameters,
17553                           files_=files_,
17554                           timeout_=timeout_,
17555                           check_=check_)
17556
17557    def addUser(
17558            self,
17559            *,
17560            group_alias: str,
17561            usernameOrEmail: str,
17562            # Out-of-band parameters:
17563            files_: Optional[Mapping[str, BinaryIO]] = None,
17564            check_: bool = True,
17565            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
17566        r"""Add identity to group
17567
17568        Args:
17569            group_alias:
17570            usernameOrEmail:
17571
17572        Returns:
17573            The API result object.
17574        """
17575        parameters: Dict[str, str] = {
17576            'group_alias': group_alias,
17577            'usernameOrEmail': usernameOrEmail,
17578        }
17579        self._client.query('/api/group/addUser/',
17580                           payload=parameters,
17581                           files_=files_,
17582                           timeout_=timeout_,
17583                           check_=check_)
17584
17585    def removeUser(
17586            self,
17587            *,
17588            group_alias: str,
17589            usernameOrEmail: str,
17590            # Out-of-band parameters:
17591            files_: Optional[Mapping[str, BinaryIO]] = None,
17592            check_: bool = True,
17593            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
17594        r"""Remove user from group
17595
17596        Args:
17597            group_alias:
17598            usernameOrEmail:
17599
17600        Returns:
17601            The API result object.
17602        """
17603        parameters: Dict[str, str] = {
17604            'group_alias': group_alias,
17605            'usernameOrEmail': usernameOrEmail,
17606        }
17607        self._client.query('/api/group/removeUser/',
17608                           payload=parameters,
17609                           files_=files_,
17610                           timeout_=timeout_,
17611                           check_=check_)
17612
17613    def myList(
17614        self,
17615        *,
17616        # Out-of-band parameters:
17617        files_: Optional[Mapping[str, BinaryIO]] = None,
17618        check_: bool = True,
17619        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
17620    ) -> GroupMyListResponse:
17621        r"""Returns a list of groups by owner
17622
17623        Returns:
17624            The API result object.
17625        """
17626        parameters: Dict[str, str] = {}
17627        return _OmegaUp_Controllers_Group__apiMyList(
17628            **self._client.query('/api/group/myList/',
17629                                 payload=parameters,
17630                                 files_=files_,
17631                                 timeout_=timeout_,
17632                                 check_=check_))
17633
17634    def list(
17635            self,
17636            *,
17637            query: Optional[str] = None,
17638            # Out-of-band parameters:
17639            files_: Optional[Mapping[str, BinaryIO]] = None,
17640            check_: bool = True,
17641            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
17642    ) -> GroupListResponse:
17643        r"""Returns a list of groups that match a partial name. This returns an
17644        array instead of an object since it is used by typeahead.
17645
17646        Args:
17647            query:
17648
17649        Returns:
17650            The API result object.
17651        """
17652        parameters: Dict[str, str] = {}
17653        if query is not None:
17654            parameters['query'] = query
17655        return [
17656            _GroupListItem(**v) for v in self._client.query('/api/group/list/',
17657                                                            payload=parameters,
17658                                                            files_=files_,
17659                                                            timeout_=timeout_,
17660                                                            check_=check_)
17661        ]
17662
17663    def details(
17664        self,
17665        *,
17666        group_alias: str,
17667        # Out-of-band parameters:
17668        files_: Optional[Mapping[str, BinaryIO]] = None,
17669        check_: bool = True,
17670        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
17671    ) -> GroupDetailsResponse:
17672        r"""Details of a group (scoreboards)
17673
17674        Args:
17675            group_alias:
17676
17677        Returns:
17678            The API result object.
17679        """
17680        parameters: Dict[str, str] = {
17681            'group_alias': group_alias,
17682        }
17683        return _OmegaUp_Controllers_Group__apiDetails(
17684            **self._client.query('/api/group/details/',
17685                                 payload=parameters,
17686                                 files_=files_,
17687                                 timeout_=timeout_,
17688                                 check_=check_))
17689
17690    def members(
17691        self,
17692        *,
17693        group_alias: str,
17694        # Out-of-band parameters:
17695        files_: Optional[Mapping[str, BinaryIO]] = None,
17696        check_: bool = True,
17697        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
17698    ) -> GroupMembersResponse:
17699        r"""Members of a group (usernames only).
17700
17701        Args:
17702            group_alias:
17703
17704        Returns:
17705            The API result object.
17706        """
17707        parameters: Dict[str, str] = {
17708            'group_alias': group_alias,
17709        }
17710        return _OmegaUp_Controllers_Group__apiMembers(
17711            **self._client.query('/api/group/members/',
17712                                 payload=parameters,
17713                                 files_=files_,
17714                                 timeout_=timeout_,
17715                                 check_=check_))
17716
17717    def createScoreboard(
17718            self,
17719            *,
17720            group_alias: str,
17721            name: str,
17722            alias: Optional[str] = None,
17723            description: Optional[str] = None,
17724            # Out-of-band parameters:
17725            files_: Optional[Mapping[str, BinaryIO]] = None,
17726            check_: bool = True,
17727            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
17728        r"""Create a scoreboard set to a group
17729
17730        Args:
17731            group_alias:
17732            name:
17733            alias:
17734            description:
17735
17736        Returns:
17737            The API result object.
17738        """
17739        parameters: Dict[str, str] = {
17740            'group_alias': group_alias,
17741            'name': name,
17742        }
17743        if alias is not None:
17744            parameters['alias'] = alias
17745        if description is not None:
17746            parameters['description'] = description
17747        self._client.query('/api/group/createScoreboard/',
17748                           payload=parameters,
17749                           files_=files_,
17750                           timeout_=timeout_,
17751                           check_=check_)
17752
17753
17754GroupScoreboardDetailsResponse = _GroupScoreboardDetails
17755"""The return type of the GroupScoreboardDetails API."""
17756
17757GroupScoreboardListResponse = _OmegaUp_Controllers_GroupScoreboard__apiList
17758"""The return type of the GroupScoreboardList API."""
17759
17760
17761class GroupScoreboard:
17762    r"""GroupScoreboardController
17763    """
17764    def __init__(self, client: 'Client') -> None:
17765        self._client = client
17766
17767    def addContest(
17768            self,
17769            *,
17770            contest_alias: str,
17771            group_alias: str,
17772            scoreboard_alias: str,
17773            weight: float,
17774            only_ac: Optional[bool] = None,
17775            # Out-of-band parameters:
17776            files_: Optional[Mapping[str, BinaryIO]] = None,
17777            check_: bool = True,
17778            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
17779        r"""Add contest to a group scoreboard
17780
17781        Args:
17782            contest_alias:
17783            group_alias:
17784            scoreboard_alias:
17785            weight:
17786            only_ac:
17787
17788        Returns:
17789            The API result object.
17790        """
17791        parameters: Dict[str, str] = {
17792            'contest_alias': contest_alias,
17793            'group_alias': group_alias,
17794            'scoreboard_alias': scoreboard_alias,
17795            'weight': str(weight),
17796        }
17797        if only_ac is not None:
17798            parameters['only_ac'] = str(only_ac)
17799        self._client.query('/api/groupScoreboard/addContest/',
17800                           payload=parameters,
17801                           files_=files_,
17802                           timeout_=timeout_,
17803                           check_=check_)
17804
17805    def removeContest(
17806            self,
17807            *,
17808            contest_alias: str,
17809            group_alias: str,
17810            scoreboard_alias: str,
17811            # Out-of-band parameters:
17812            files_: Optional[Mapping[str, BinaryIO]] = None,
17813            check_: bool = True,
17814            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
17815        r"""Add contest to a group scoreboard
17816
17817        Args:
17818            contest_alias:
17819            group_alias:
17820            scoreboard_alias:
17821
17822        Returns:
17823            The API result object.
17824        """
17825        parameters: Dict[str, str] = {
17826            'contest_alias': contest_alias,
17827            'group_alias': group_alias,
17828            'scoreboard_alias': scoreboard_alias,
17829        }
17830        self._client.query('/api/groupScoreboard/removeContest/',
17831                           payload=parameters,
17832                           files_=files_,
17833                           timeout_=timeout_,
17834                           check_=check_)
17835
17836    def details(
17837        self,
17838        *,
17839        group_alias: str,
17840        scoreboard_alias: str,
17841        # Out-of-band parameters:
17842        files_: Optional[Mapping[str, BinaryIO]] = None,
17843        check_: bool = True,
17844        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
17845    ) -> GroupScoreboardDetailsResponse:
17846        r"""Details of a scoreboard. Returns a list with all contests that belong to
17847        the given scoreboard_alias
17848
17849        Args:
17850            group_alias:
17851            scoreboard_alias:
17852
17853        Returns:
17854            The API result object.
17855        """
17856        parameters: Dict[str, str] = {
17857            'group_alias': group_alias,
17858            'scoreboard_alias': scoreboard_alias,
17859        }
17860        return _GroupScoreboardDetails(
17861            **self._client.query('/api/groupScoreboard/details/',
17862                                 payload=parameters,
17863                                 files_=files_,
17864                                 timeout_=timeout_,
17865                                 check_=check_))
17866
17867    def list(
17868        self,
17869        *,
17870        group_alias: Optional[str] = None,
17871        # Out-of-band parameters:
17872        files_: Optional[Mapping[str, BinaryIO]] = None,
17873        check_: bool = True,
17874        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
17875    ) -> GroupScoreboardListResponse:
17876        r"""Details of a scoreboard
17877
17878        Args:
17879            group_alias:
17880
17881        Returns:
17882            The API result object.
17883        """
17884        parameters: Dict[str, str] = {}
17885        if group_alias is not None:
17886            parameters['group_alias'] = group_alias
17887        return _OmegaUp_Controllers_GroupScoreboard__apiList(
17888            **self._client.query('/api/groupScoreboard/list/',
17889                                 payload=parameters,
17890                                 files_=files_,
17891                                 timeout_=timeout_,
17892                                 check_=check_))
17893
17894
17895IdentityCreateResponse = _OmegaUp_Controllers_Identity__apiCreate
17896"""The return type of the IdentityCreate API."""
17897
17898
17899class Identity:
17900    r"""IdentityController
17901    """
17902    def __init__(self, client: 'Client') -> None:
17903        self._client = client
17904
17905    def create(
17906        self,
17907        *,
17908        gender: str,
17909        name: str,
17910        password: str,
17911        school_name: str,
17912        username: str,
17913        country_id: Optional[str] = None,
17914        group_alias: Optional[str] = None,
17915        identities: Optional[Any] = None,
17916        state_id: Optional[str] = None,
17917        # Out-of-band parameters:
17918        files_: Optional[Mapping[str, BinaryIO]] = None,
17919        check_: bool = True,
17920        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
17921    ) -> IdentityCreateResponse:
17922        r"""Entry point for Create an Identity API
17923
17924        Args:
17925            gender:
17926            name:
17927            password:
17928            school_name:
17929            username:
17930            country_id:
17931            group_alias:
17932            identities:
17933            state_id:
17934
17935        Returns:
17936            The API result object.
17937        """
17938        parameters: Dict[str, str] = {
17939            'gender': gender,
17940            'name': name,
17941            'password': password,
17942            'school_name': school_name,
17943            'username': username,
17944        }
17945        if country_id is not None:
17946            parameters['country_id'] = country_id
17947        if group_alias is not None:
17948            parameters['group_alias'] = group_alias
17949        if identities is not None:
17950            parameters['identities'] = str(identities)
17951        if state_id is not None:
17952            parameters['state_id'] = state_id
17953        return _OmegaUp_Controllers_Identity__apiCreate(
17954            **self._client.query('/api/identity/create/',
17955                                 payload=parameters,
17956                                 files_=files_,
17957                                 timeout_=timeout_,
17958                                 check_=check_))
17959
17960    def bulkCreate(
17961            self,
17962            *,
17963            identities: str,
17964            group_alias: Optional[str] = None,
17965            name: Optional[Any] = None,
17966            username: Optional[Any] = None,
17967            # Out-of-band parameters:
17968            files_: Optional[Mapping[str, BinaryIO]] = None,
17969            check_: bool = True,
17970            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
17971        r"""Entry point for Create bulk Identities API
17972
17973        Args:
17974            identities:
17975            group_alias:
17976            name:
17977            username:
17978
17979        Returns:
17980            The API result object.
17981        """
17982        parameters: Dict[str, str] = {
17983            'identities': identities,
17984        }
17985        if group_alias is not None:
17986            parameters['group_alias'] = group_alias
17987        if name is not None:
17988            parameters['name'] = str(name)
17989        if username is not None:
17990            parameters['username'] = str(username)
17991        self._client.query('/api/identity/bulkCreate/',
17992                           payload=parameters,
17993                           files_=files_,
17994                           timeout_=timeout_,
17995                           check_=check_)
17996
17997    def bulkCreateForTeams(
17998            self,
17999            *,
18000            team_group_alias: str,
18001            team_identities: str,
18002            # Out-of-band parameters:
18003            files_: Optional[Mapping[str, BinaryIO]] = None,
18004            check_: bool = True,
18005            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
18006        r"""Entry point for Create bulk Identities for teams API
18007
18008        Args:
18009            team_group_alias:
18010            team_identities:
18011
18012        Returns:
18013            The API result object.
18014        """
18015        parameters: Dict[str, str] = {
18016            'team_group_alias': team_group_alias,
18017            'team_identities': team_identities,
18018        }
18019        self._client.query('/api/identity/bulkCreateForTeams/',
18020                           payload=parameters,
18021                           files_=files_,
18022                           timeout_=timeout_,
18023                           check_=check_)
18024
18025    def updateIdentityTeam(
18026            self,
18027            *,
18028            gender: str,
18029            group_alias: str,
18030            name: str,
18031            original_username: str,
18032            school_name: str,
18033            username: str,
18034            country_id: Optional[str] = None,
18035            identities: Optional[Any] = None,
18036            state_id: Optional[str] = None,
18037            # Out-of-band parameters:
18038            files_: Optional[Mapping[str, BinaryIO]] = None,
18039            check_: bool = True,
18040            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
18041        r"""Entry point for Update an Identity team API
18042
18043        Args:
18044            gender:
18045            group_alias:
18046            name:
18047            original_username:
18048            school_name:
18049            username:
18050            country_id:
18051            identities:
18052            state_id:
18053
18054        Returns:
18055            The API result object.
18056        """
18057        parameters: Dict[str, str] = {
18058            'gender': gender,
18059            'group_alias': group_alias,
18060            'name': name,
18061            'original_username': original_username,
18062            'school_name': school_name,
18063            'username': username,
18064        }
18065        if country_id is not None:
18066            parameters['country_id'] = country_id
18067        if identities is not None:
18068            parameters['identities'] = str(identities)
18069        if state_id is not None:
18070            parameters['state_id'] = state_id
18071        self._client.query('/api/identity/updateIdentityTeam/',
18072                           payload=parameters,
18073                           files_=files_,
18074                           timeout_=timeout_,
18075                           check_=check_)
18076
18077    def update(
18078            self,
18079            *,
18080            gender: str,
18081            group_alias: str,
18082            name: str,
18083            original_username: str,
18084            school_name: str,
18085            username: str,
18086            country_id: Optional[str] = None,
18087            identities: Optional[Any] = None,
18088            state_id: Optional[str] = None,
18089            # Out-of-band parameters:
18090            files_: Optional[Mapping[str, BinaryIO]] = None,
18091            check_: bool = True,
18092            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
18093        r"""Entry point for Update an Identity API
18094
18095        Args:
18096            gender:
18097            group_alias:
18098            name:
18099            original_username:
18100            school_name:
18101            username:
18102            country_id:
18103            identities:
18104            state_id:
18105
18106        Returns:
18107            The API result object.
18108        """
18109        parameters: Dict[str, str] = {
18110            'gender': gender,
18111            'group_alias': group_alias,
18112            'name': name,
18113            'original_username': original_username,
18114            'school_name': school_name,
18115            'username': username,
18116        }
18117        if country_id is not None:
18118            parameters['country_id'] = country_id
18119        if identities is not None:
18120            parameters['identities'] = str(identities)
18121        if state_id is not None:
18122            parameters['state_id'] = state_id
18123        self._client.query('/api/identity/update/',
18124                           payload=parameters,
18125                           files_=files_,
18126                           timeout_=timeout_,
18127                           check_=check_)
18128
18129    def changePassword(
18130            self,
18131            *,
18132            group_alias: str,
18133            password: str,
18134            username: str,
18135            identities: Optional[Any] = None,
18136            name: Optional[Any] = None,
18137            # Out-of-band parameters:
18138            files_: Optional[Mapping[str, BinaryIO]] = None,
18139            check_: bool = True,
18140            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
18141        r"""Entry point for change passowrd of an identity
18142
18143        Args:
18144            group_alias:
18145            password:
18146            username:
18147            identities:
18148            name:
18149
18150        Returns:
18151            The API result object.
18152        """
18153        parameters: Dict[str, str] = {
18154            'group_alias': group_alias,
18155            'password': password,
18156            'username': username,
18157        }
18158        if identities is not None:
18159            parameters['identities'] = str(identities)
18160        if name is not None:
18161            parameters['name'] = str(name)
18162        self._client.query('/api/identity/changePassword/',
18163                           payload=parameters,
18164                           files_=files_,
18165                           timeout_=timeout_,
18166                           check_=check_)
18167
18168    def selectIdentity(
18169            self,
18170            *,
18171            usernameOrEmail: str,
18172            auth_token: Optional[str] = None,
18173            # Out-of-band parameters:
18174            files_: Optional[Mapping[str, BinaryIO]] = None,
18175            check_: bool = True,
18176            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
18177        r"""Entry point for switching between associated identities for a user
18178
18179        Args:
18180            usernameOrEmail:
18181            auth_token:
18182
18183        Returns:
18184            The API result object.
18185        """
18186        parameters: Dict[str, str] = {
18187            'usernameOrEmail': usernameOrEmail,
18188        }
18189        if auth_token is not None:
18190            parameters['auth_token'] = auth_token
18191        self._client.query('/api/identity/selectIdentity/',
18192                           payload=parameters,
18193                           files_=files_,
18194                           timeout_=timeout_,
18195                           check_=check_)
18196
18197
18198NotificationMyListResponse = _OmegaUp_Controllers_Notification__apiMyList
18199"""The return type of the NotificationMyList API."""
18200
18201
18202class Notification:
18203    r"""BadgesController
18204    """
18205    def __init__(self, client: 'Client') -> None:
18206        self._client = client
18207
18208    def myList(
18209        self,
18210        *,
18211        # Out-of-band parameters:
18212        files_: Optional[Mapping[str, BinaryIO]] = None,
18213        check_: bool = True,
18214        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
18215    ) -> NotificationMyListResponse:
18216        r"""Returns a list of unread notifications for user
18217
18218        Returns:
18219            The API result object.
18220        """
18221        parameters: Dict[str, str] = {}
18222        return _OmegaUp_Controllers_Notification__apiMyList(
18223            **self._client.query('/api/notification/myList/',
18224                                 payload=parameters,
18225                                 files_=files_,
18226                                 timeout_=timeout_,
18227                                 check_=check_))
18228
18229    def readNotifications(
18230            self,
18231            *,
18232            notifications: Optional[Any] = None,
18233            # Out-of-band parameters:
18234            files_: Optional[Mapping[str, BinaryIO]] = None,
18235            check_: bool = True,
18236            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
18237        r"""Updates notifications as read in database
18238
18239        Args:
18240            notifications:
18241
18242        Returns:
18243            The API result object.
18244        """
18245        parameters: Dict[str, str] = {}
18246        if notifications is not None:
18247            parameters['notifications'] = str(notifications)
18248        self._client.query('/api/notification/readNotifications/',
18249                           payload=parameters,
18250                           files_=files_,
18251                           timeout_=timeout_,
18252                           check_=check_)
18253
18254
18255ProblemAddTagResponse = _OmegaUp_Controllers_Problem__apiAddTag
18256"""The return type of the ProblemAddTag API."""
18257
18258ProblemAdminsResponse = _OmegaUp_Controllers_Problem__apiAdmins
18259"""The return type of the ProblemAdmins API."""
18260
18261ProblemTagsResponse = _OmegaUp_Controllers_Problem__apiTags
18262"""The return type of the ProblemTags API."""
18263
18264ProblemUpdateResponse = _OmegaUp_Controllers_Problem__apiUpdate
18265"""The return type of the ProblemUpdate API."""
18266
18267ProblemDetailsResponse = _ProblemDetails
18268"""The return type of the ProblemDetails API."""
18269
18270ProblemSolutionResponse = _OmegaUp_Controllers_Problem__apiSolution
18271"""The return type of the ProblemSolution API."""
18272
18273ProblemVersionsResponse = _OmegaUp_Controllers_Problem__apiVersions
18274"""The return type of the ProblemVersions API."""
18275
18276ProblemRunsDiffResponse = _OmegaUp_Controllers_Problem__apiRunsDiff
18277"""The return type of the ProblemRunsDiff API."""
18278
18279ProblemRunsResponse = _OmegaUp_Controllers_Problem__apiRuns
18280"""The return type of the ProblemRuns API."""
18281
18282ProblemClarificationsResponse = _OmegaUp_Controllers_Problem__apiClarifications
18283"""The return type of the ProblemClarifications API."""
18284
18285ProblemStatsResponse = _OmegaUp_Controllers_Problem__apiStats
18286"""The return type of the ProblemStats API."""
18287
18288ProblemListForTypeaheadResponse = _OmegaUp_Controllers_Problem__apiListForTypeahead
18289"""The return type of the ProblemListForTypeahead API."""
18290
18291ProblemListResponse = _OmegaUp_Controllers_Problem__apiList
18292"""The return type of the ProblemList API."""
18293
18294ProblemAdminListResponse = _OmegaUp_Controllers_Problem__apiAdminList
18295"""The return type of the ProblemAdminList API."""
18296
18297ProblemMyListResponse = _OmegaUp_Controllers_Problem__apiMyList
18298"""The return type of the ProblemMyList API."""
18299
18300ProblemBestScoreResponse = _OmegaUp_Controllers_Problem__apiBestScore
18301"""The return type of the ProblemBestScore API."""
18302
18303ProblemRandomLanguageProblemResponse = _OmegaUp_Controllers_Problem__apiRandomLanguageProblem
18304"""The return type of the ProblemRandomLanguageProblem API."""
18305
18306ProblemRandomKarelProblemResponse = _OmegaUp_Controllers_Problem__apiRandomKarelProblem
18307"""The return type of the ProblemRandomKarelProblem API."""
18308
18309
18310class Problem:
18311    r"""ProblemsController
18312    """
18313    def __init__(self, client: 'Client') -> None:
18314        self._client = client
18315
18316    def create(
18317            self,
18318            *,
18319            problem_alias: str,
18320            visibility: str,
18321            allow_user_add_tags: Optional[bool] = None,
18322            email_clarifications: Optional[bool] = None,
18323            extra_wall_time: Optional[Any] = None,
18324            group_score_policy: Optional[str] = None,
18325            input_limit: Optional[Any] = None,
18326            languages: Optional[Any] = None,
18327            memory_limit: Optional[Any] = None,
18328            output_limit: Optional[Any] = None,
18329            overall_wall_time_limit: Optional[Any] = None,
18330            problem_level: Optional[str] = None,
18331            selected_tags: Optional[str] = None,
18332            show_diff: Optional[str] = None,
18333            source: Optional[str] = None,
18334            time_limit: Optional[Any] = None,
18335            title: Optional[str] = None,
18336            update_published: Optional[str] = None,
18337            validator: Optional[str] = None,
18338            validator_time_limit: Optional[Any] = None,
18339            # Out-of-band parameters:
18340            files_: Optional[Mapping[str, BinaryIO]] = None,
18341            check_: bool = True,
18342            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
18343        r"""Create a new problem
18344
18345        Args:
18346            problem_alias:
18347            visibility:
18348            allow_user_add_tags:
18349            email_clarifications:
18350            extra_wall_time:
18351            group_score_policy:
18352            input_limit:
18353            languages:
18354            memory_limit:
18355            output_limit:
18356            overall_wall_time_limit:
18357            problem_level:
18358            selected_tags:
18359            show_diff:
18360            source:
18361            time_limit:
18362            title:
18363            update_published:
18364            validator:
18365            validator_time_limit:
18366
18367        Returns:
18368            The API result object.
18369        """
18370        parameters: Dict[str, str] = {
18371            'problem_alias': problem_alias,
18372            'visibility': visibility,
18373        }
18374        if allow_user_add_tags is not None:
18375            parameters['allow_user_add_tags'] = str(allow_user_add_tags)
18376        if email_clarifications is not None:
18377            parameters['email_clarifications'] = str(email_clarifications)
18378        if extra_wall_time is not None:
18379            parameters['extra_wall_time'] = str(extra_wall_time)
18380        if group_score_policy is not None:
18381            parameters['group_score_policy'] = group_score_policy
18382        if input_limit is not None:
18383            parameters['input_limit'] = str(input_limit)
18384        if languages is not None:
18385            parameters['languages'] = str(languages)
18386        if memory_limit is not None:
18387            parameters['memory_limit'] = str(memory_limit)
18388        if output_limit is not None:
18389            parameters['output_limit'] = str(output_limit)
18390        if overall_wall_time_limit is not None:
18391            parameters['overall_wall_time_limit'] = str(
18392                overall_wall_time_limit)
18393        if problem_level is not None:
18394            parameters['problem_level'] = problem_level
18395        if selected_tags is not None:
18396            parameters['selected_tags'] = selected_tags
18397        if show_diff is not None:
18398            parameters['show_diff'] = show_diff
18399        if source is not None:
18400            parameters['source'] = source
18401        if time_limit is not None:
18402            parameters['time_limit'] = str(time_limit)
18403        if title is not None:
18404            parameters['title'] = title
18405        if update_published is not None:
18406            parameters['update_published'] = update_published
18407        if validator is not None:
18408            parameters['validator'] = validator
18409        if validator_time_limit is not None:
18410            parameters['validator_time_limit'] = str(validator_time_limit)
18411        self._client.query('/api/problem/create/',
18412                           payload=parameters,
18413                           files_=files_,
18414                           timeout_=timeout_,
18415                           check_=check_)
18416
18417    def addAdmin(
18418            self,
18419            *,
18420            problem_alias: str,
18421            usernameOrEmail: str,
18422            # Out-of-band parameters:
18423            files_: Optional[Mapping[str, BinaryIO]] = None,
18424            check_: bool = True,
18425            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
18426        r"""Adds an admin to a problem
18427
18428        Args:
18429            problem_alias:
18430            usernameOrEmail:
18431
18432        Returns:
18433            The API result object.
18434        """
18435        parameters: Dict[str, str] = {
18436            'problem_alias': problem_alias,
18437            'usernameOrEmail': usernameOrEmail,
18438        }
18439        self._client.query('/api/problem/addAdmin/',
18440                           payload=parameters,
18441                           files_=files_,
18442                           timeout_=timeout_,
18443                           check_=check_)
18444
18445    def addGroupAdmin(
18446            self,
18447            *,
18448            group: str,
18449            problem_alias: str,
18450            # Out-of-band parameters:
18451            files_: Optional[Mapping[str, BinaryIO]] = None,
18452            check_: bool = True,
18453            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
18454        r"""Adds a group admin to a problem
18455
18456        Args:
18457            group:
18458            problem_alias:
18459
18460        Returns:
18461            The API result object.
18462        """
18463        parameters: Dict[str, str] = {
18464            'group': group,
18465            'problem_alias': problem_alias,
18466        }
18467        self._client.query('/api/problem/addGroupAdmin/',
18468                           payload=parameters,
18469                           files_=files_,
18470                           timeout_=timeout_,
18471                           check_=check_)
18472
18473    def updateProblemLevel(
18474            self,
18475            *,
18476            problem_alias: str,
18477            level_tag: Optional[str] = None,
18478            # Out-of-band parameters:
18479            files_: Optional[Mapping[str, BinaryIO]] = None,
18480            check_: bool = True,
18481            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
18482        r"""Updates the problem level of a problem
18483
18484        Args:
18485            problem_alias:
18486            level_tag:
18487
18488        Returns:
18489            The API result object.
18490        """
18491        parameters: Dict[str, str] = {
18492            'problem_alias': problem_alias,
18493        }
18494        if level_tag is not None:
18495            parameters['level_tag'] = level_tag
18496        self._client.query('/api/problem/updateProblemLevel/',
18497                           payload=parameters,
18498                           files_=files_,
18499                           timeout_=timeout_,
18500                           check_=check_)
18501
18502    def addTag(
18503        self,
18504        *,
18505        name: str,
18506        problem_alias: str,
18507        public: Optional[bool] = None,
18508        # Out-of-band parameters:
18509        files_: Optional[Mapping[str, BinaryIO]] = None,
18510        check_: bool = True,
18511        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
18512    ) -> ProblemAddTagResponse:
18513        r"""Adds a tag to a problem
18514
18515        Args:
18516            name:
18517            problem_alias:
18518            public:
18519
18520        Returns:
18521            The API result object.
18522        """
18523        parameters: Dict[str, str] = {
18524            'name': name,
18525            'problem_alias': problem_alias,
18526        }
18527        if public is not None:
18528            parameters['public'] = str(public)
18529        return _OmegaUp_Controllers_Problem__apiAddTag(
18530            **self._client.query('/api/problem/addTag/',
18531                                 payload=parameters,
18532                                 files_=files_,
18533                                 timeout_=timeout_,
18534                                 check_=check_))
18535
18536    def removeAdmin(
18537            self,
18538            *,
18539            problem_alias: str,
18540            usernameOrEmail: str,
18541            # Out-of-band parameters:
18542            files_: Optional[Mapping[str, BinaryIO]] = None,
18543            check_: bool = True,
18544            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
18545        r"""Removes an admin from a problem
18546
18547        Args:
18548            problem_alias:
18549            usernameOrEmail:
18550
18551        Returns:
18552            The API result object.
18553        """
18554        parameters: Dict[str, str] = {
18555            'problem_alias': problem_alias,
18556            'usernameOrEmail': usernameOrEmail,
18557        }
18558        self._client.query('/api/problem/removeAdmin/',
18559                           payload=parameters,
18560                           files_=files_,
18561                           timeout_=timeout_,
18562                           check_=check_)
18563
18564    def removeGroupAdmin(
18565            self,
18566            *,
18567            group: str,
18568            problem_alias: str,
18569            # Out-of-band parameters:
18570            files_: Optional[Mapping[str, BinaryIO]] = None,
18571            check_: bool = True,
18572            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
18573        r"""Removes a group admin from a problem
18574
18575        Args:
18576            group:
18577            problem_alias:
18578
18579        Returns:
18580            The API result object.
18581        """
18582        parameters: Dict[str, str] = {
18583            'group': group,
18584            'problem_alias': problem_alias,
18585        }
18586        self._client.query('/api/problem/removeGroupAdmin/',
18587                           payload=parameters,
18588                           files_=files_,
18589                           timeout_=timeout_,
18590                           check_=check_)
18591
18592    def removeTag(
18593            self,
18594            *,
18595            name: str,
18596            problem_alias: str,
18597            # Out-of-band parameters:
18598            files_: Optional[Mapping[str, BinaryIO]] = None,
18599            check_: bool = True,
18600            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
18601        r"""Removes a tag from a contest
18602
18603        Args:
18604            name:
18605            problem_alias:
18606
18607        Returns:
18608            The API result object.
18609        """
18610        parameters: Dict[str, str] = {
18611            'name': name,
18612            'problem_alias': problem_alias,
18613        }
18614        self._client.query('/api/problem/removeTag/',
18615                           payload=parameters,
18616                           files_=files_,
18617                           timeout_=timeout_,
18618                           check_=check_)
18619
18620    def delete(
18621            self,
18622            *,
18623            problem_alias: str,
18624            # Out-of-band parameters:
18625            files_: Optional[Mapping[str, BinaryIO]] = None,
18626            check_: bool = True,
18627            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
18628        r"""Removes a problem whether user is the creator
18629
18630        Args:
18631            problem_alias:
18632
18633        Returns:
18634            The API result object.
18635        """
18636        parameters: Dict[str, str] = {
18637            'problem_alias': problem_alias,
18638        }
18639        self._client.query('/api/problem/delete/',
18640                           payload=parameters,
18641                           files_=files_,
18642                           timeout_=timeout_,
18643                           check_=check_)
18644
18645    def admins(
18646        self,
18647        *,
18648        problem_alias: str,
18649        # Out-of-band parameters:
18650        files_: Optional[Mapping[str, BinaryIO]] = None,
18651        check_: bool = True,
18652        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
18653    ) -> ProblemAdminsResponse:
18654        r"""Returns all problem administrators
18655
18656        Args:
18657            problem_alias:
18658
18659        Returns:
18660            The API result object.
18661        """
18662        parameters: Dict[str, str] = {
18663            'problem_alias': problem_alias,
18664        }
18665        return _OmegaUp_Controllers_Problem__apiAdmins(
18666            **self._client.query('/api/problem/admins/',
18667                                 payload=parameters,
18668                                 files_=files_,
18669                                 timeout_=timeout_,
18670                                 check_=check_))
18671
18672    def tags(
18673        self,
18674        *,
18675        problem_alias: str,
18676        include_voted: Optional[Any] = None,
18677        # Out-of-band parameters:
18678        files_: Optional[Mapping[str, BinaryIO]] = None,
18679        check_: bool = True,
18680        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
18681    ) -> ProblemTagsResponse:
18682        r"""Returns every tag associated to a given problem.
18683
18684        Args:
18685            problem_alias:
18686            include_voted:
18687
18688        Returns:
18689            The API result object.
18690        """
18691        parameters: Dict[str, str] = {
18692            'problem_alias': problem_alias,
18693        }
18694        if include_voted is not None:
18695            parameters['include_voted'] = str(include_voted)
18696        return _OmegaUp_Controllers_Problem__apiTags(
18697            **self._client.query('/api/problem/tags/',
18698                                 payload=parameters,
18699                                 files_=files_,
18700                                 timeout_=timeout_,
18701                                 check_=check_))
18702
18703    def rejudge(
18704            self,
18705            *,
18706            problem_alias: str,
18707            # Out-of-band parameters:
18708            files_: Optional[Mapping[str, BinaryIO]] = None,
18709            check_: bool = True,
18710            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
18711        r"""Rejudge problem
18712
18713        Args:
18714            problem_alias:
18715
18716        Returns:
18717            The API result object.
18718        """
18719        parameters: Dict[str, str] = {
18720            'problem_alias': problem_alias,
18721        }
18722        self._client.query('/api/problem/rejudge/',
18723                           payload=parameters,
18724                           files_=files_,
18725                           timeout_=timeout_,
18726                           check_=check_)
18727
18728    def update(
18729        self,
18730        *,
18731        message: str,
18732        problem_alias: str,
18733        allow_user_add_tags: Optional[bool] = None,
18734        email_clarifications: Optional[bool] = None,
18735        extra_wall_time: Optional[Any] = None,
18736        group_score_policy: Optional[str] = None,
18737        input_limit: Optional[Any] = None,
18738        languages: Optional[Any] = None,
18739        memory_limit: Optional[Any] = None,
18740        output_limit: Optional[Any] = None,
18741        overall_wall_time_limit: Optional[Any] = None,
18742        problem_level: Optional[str] = None,
18743        redirect: Optional[Any] = None,
18744        selected_tags: Optional[str] = None,
18745        show_diff: Optional[str] = None,
18746        source: Optional[str] = None,
18747        time_limit: Optional[Any] = None,
18748        title: Optional[str] = None,
18749        update_published: Optional[str] = None,
18750        validator: Optional[str] = None,
18751        validator_time_limit: Optional[Any] = None,
18752        visibility: Optional[str] = None,
18753        # Out-of-band parameters:
18754        files_: Optional[Mapping[str, BinaryIO]] = None,
18755        check_: bool = True,
18756        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
18757    ) -> ProblemUpdateResponse:
18758        r"""Update problem contents
18759
18760        Args:
18761            message:
18762            problem_alias:
18763            allow_user_add_tags:
18764            email_clarifications:
18765            extra_wall_time:
18766            group_score_policy:
18767            input_limit:
18768            languages:
18769            memory_limit:
18770            output_limit:
18771            overall_wall_time_limit:
18772            problem_level:
18773            redirect:
18774            selected_tags:
18775            show_diff:
18776            source:
18777            time_limit:
18778            title:
18779            update_published:
18780            validator:
18781            validator_time_limit:
18782            visibility:
18783
18784        Returns:
18785            The API result object.
18786        """
18787        parameters: Dict[str, str] = {
18788            'message': message,
18789            'problem_alias': problem_alias,
18790        }
18791        if allow_user_add_tags is not None:
18792            parameters['allow_user_add_tags'] = str(allow_user_add_tags)
18793        if email_clarifications is not None:
18794            parameters['email_clarifications'] = str(email_clarifications)
18795        if extra_wall_time is not None:
18796            parameters['extra_wall_time'] = str(extra_wall_time)
18797        if group_score_policy is not None:
18798            parameters['group_score_policy'] = group_score_policy
18799        if input_limit is not None:
18800            parameters['input_limit'] = str(input_limit)
18801        if languages is not None:
18802            parameters['languages'] = str(languages)
18803        if memory_limit is not None:
18804            parameters['memory_limit'] = str(memory_limit)
18805        if output_limit is not None:
18806            parameters['output_limit'] = str(output_limit)
18807        if overall_wall_time_limit is not None:
18808            parameters['overall_wall_time_limit'] = str(
18809                overall_wall_time_limit)
18810        if problem_level is not None:
18811            parameters['problem_level'] = problem_level
18812        if redirect is not None:
18813            parameters['redirect'] = str(redirect)
18814        if selected_tags is not None:
18815            parameters['selected_tags'] = selected_tags
18816        if show_diff is not None:
18817            parameters['show_diff'] = show_diff
18818        if source is not None:
18819            parameters['source'] = source
18820        if time_limit is not None:
18821            parameters['time_limit'] = str(time_limit)
18822        if title is not None:
18823            parameters['title'] = title
18824        if update_published is not None:
18825            parameters['update_published'] = update_published
18826        if validator is not None:
18827            parameters['validator'] = validator
18828        if validator_time_limit is not None:
18829            parameters['validator_time_limit'] = str(validator_time_limit)
18830        if visibility is not None:
18831            parameters['visibility'] = visibility
18832        return _OmegaUp_Controllers_Problem__apiUpdate(
18833            **self._client.query('/api/problem/update/',
18834                                 payload=parameters,
18835                                 files_=files_,
18836                                 timeout_=timeout_,
18837                                 check_=check_))
18838
18839    def updateStatement(
18840            self,
18841            *,
18842            message: str,
18843            problem_alias: str,
18844            statement: str,
18845            visibility: str,
18846            allow_user_add_tags: Optional[bool] = None,
18847            email_clarifications: Optional[bool] = None,
18848            extra_wall_time: Optional[Any] = None,
18849            group_score_policy: Optional[str] = None,
18850            input_limit: Optional[Any] = None,
18851            lang: Optional[Any] = None,
18852            languages: Optional[Any] = None,
18853            memory_limit: Optional[Any] = None,
18854            output_limit: Optional[Any] = None,
18855            overall_wall_time_limit: Optional[Any] = None,
18856            problem_level: Optional[str] = None,
18857            selected_tags: Optional[str] = None,
18858            show_diff: Optional[str] = None,
18859            source: Optional[str] = None,
18860            time_limit: Optional[Any] = None,
18861            title: Optional[str] = None,
18862            update_published: Optional[str] = None,
18863            validator: Optional[str] = None,
18864            validator_time_limit: Optional[Any] = None,
18865            # Out-of-band parameters:
18866            files_: Optional[Mapping[str, BinaryIO]] = None,
18867            check_: bool = True,
18868            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
18869        r"""Updates problem statement only
18870
18871        Args:
18872            message:
18873            problem_alias:
18874            statement:
18875            visibility:
18876            allow_user_add_tags:
18877            email_clarifications:
18878            extra_wall_time:
18879            group_score_policy:
18880            input_limit:
18881            lang:
18882            languages:
18883            memory_limit:
18884            output_limit:
18885            overall_wall_time_limit:
18886            problem_level:
18887            selected_tags:
18888            show_diff:
18889            source:
18890            time_limit:
18891            title:
18892            update_published:
18893            validator:
18894            validator_time_limit:
18895
18896        Returns:
18897            The API result object.
18898        """
18899        parameters: Dict[str, str] = {
18900            'message': message,
18901            'problem_alias': problem_alias,
18902            'statement': statement,
18903            'visibility': visibility,
18904        }
18905        if allow_user_add_tags is not None:
18906            parameters['allow_user_add_tags'] = str(allow_user_add_tags)
18907        if email_clarifications is not None:
18908            parameters['email_clarifications'] = str(email_clarifications)
18909        if extra_wall_time is not None:
18910            parameters['extra_wall_time'] = str(extra_wall_time)
18911        if group_score_policy is not None:
18912            parameters['group_score_policy'] = group_score_policy
18913        if input_limit is not None:
18914            parameters['input_limit'] = str(input_limit)
18915        if lang is not None:
18916            parameters['lang'] = str(lang)
18917        if languages is not None:
18918            parameters['languages'] = str(languages)
18919        if memory_limit is not None:
18920            parameters['memory_limit'] = str(memory_limit)
18921        if output_limit is not None:
18922            parameters['output_limit'] = str(output_limit)
18923        if overall_wall_time_limit is not None:
18924            parameters['overall_wall_time_limit'] = str(
18925                overall_wall_time_limit)
18926        if problem_level is not None:
18927            parameters['problem_level'] = problem_level
18928        if selected_tags is not None:
18929            parameters['selected_tags'] = selected_tags
18930        if show_diff is not None:
18931            parameters['show_diff'] = show_diff
18932        if source is not None:
18933            parameters['source'] = source
18934        if time_limit is not None:
18935            parameters['time_limit'] = str(time_limit)
18936        if title is not None:
18937            parameters['title'] = title
18938        if update_published is not None:
18939            parameters['update_published'] = update_published
18940        if validator is not None:
18941            parameters['validator'] = validator
18942        if validator_time_limit is not None:
18943            parameters['validator_time_limit'] = str(validator_time_limit)
18944        self._client.query('/api/problem/updateStatement/',
18945                           payload=parameters,
18946                           files_=files_,
18947                           timeout_=timeout_,
18948                           check_=check_)
18949
18950    def updateSolution(
18951            self,
18952            *,
18953            message: str,
18954            problem_alias: str,
18955            solution: str,
18956            visibility: str,
18957            allow_user_add_tags: Optional[bool] = None,
18958            email_clarifications: Optional[bool] = None,
18959            extra_wall_time: Optional[Any] = None,
18960            group_score_policy: Optional[str] = None,
18961            input_limit: Optional[Any] = None,
18962            lang: Optional[str] = None,
18963            languages: Optional[Any] = None,
18964            memory_limit: Optional[Any] = None,
18965            output_limit: Optional[Any] = None,
18966            overall_wall_time_limit: Optional[Any] = None,
18967            problem_level: Optional[str] = None,
18968            selected_tags: Optional[str] = None,
18969            show_diff: Optional[str] = None,
18970            source: Optional[str] = None,
18971            time_limit: Optional[Any] = None,
18972            title: Optional[str] = None,
18973            update_published: Optional[str] = None,
18974            validator: Optional[str] = None,
18975            validator_time_limit: Optional[Any] = None,
18976            # Out-of-band parameters:
18977            files_: Optional[Mapping[str, BinaryIO]] = None,
18978            check_: bool = True,
18979            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
18980        r"""Updates problem solution only
18981
18982        Args:
18983            message:
18984            problem_alias:
18985            solution:
18986            visibility:
18987            allow_user_add_tags:
18988            email_clarifications:
18989            extra_wall_time:
18990            group_score_policy:
18991            input_limit:
18992            lang:
18993            languages:
18994            memory_limit:
18995            output_limit:
18996            overall_wall_time_limit:
18997            problem_level:
18998            selected_tags:
18999            show_diff:
19000            source:
19001            time_limit:
19002            title:
19003            update_published:
19004            validator:
19005            validator_time_limit:
19006
19007        Returns:
19008            The API result object.
19009        """
19010        parameters: Dict[str, str] = {
19011            'message': message,
19012            'problem_alias': problem_alias,
19013            'solution': solution,
19014            'visibility': visibility,
19015        }
19016        if allow_user_add_tags is not None:
19017            parameters['allow_user_add_tags'] = str(allow_user_add_tags)
19018        if email_clarifications is not None:
19019            parameters['email_clarifications'] = str(email_clarifications)
19020        if extra_wall_time is not None:
19021            parameters['extra_wall_time'] = str(extra_wall_time)
19022        if group_score_policy is not None:
19023            parameters['group_score_policy'] = group_score_policy
19024        if input_limit is not None:
19025            parameters['input_limit'] = str(input_limit)
19026        if lang is not None:
19027            parameters['lang'] = lang
19028        if languages is not None:
19029            parameters['languages'] = str(languages)
19030        if memory_limit is not None:
19031            parameters['memory_limit'] = str(memory_limit)
19032        if output_limit is not None:
19033            parameters['output_limit'] = str(output_limit)
19034        if overall_wall_time_limit is not None:
19035            parameters['overall_wall_time_limit'] = str(
19036                overall_wall_time_limit)
19037        if problem_level is not None:
19038            parameters['problem_level'] = problem_level
19039        if selected_tags is not None:
19040            parameters['selected_tags'] = selected_tags
19041        if show_diff is not None:
19042            parameters['show_diff'] = show_diff
19043        if source is not None:
19044            parameters['source'] = source
19045        if time_limit is not None:
19046            parameters['time_limit'] = str(time_limit)
19047        if title is not None:
19048            parameters['title'] = title
19049        if update_published is not None:
19050            parameters['update_published'] = update_published
19051        if validator is not None:
19052            parameters['validator'] = validator
19053        if validator_time_limit is not None:
19054            parameters['validator_time_limit'] = str(validator_time_limit)
19055        self._client.query('/api/problem/updateSolution/',
19056                           payload=parameters,
19057                           files_=files_,
19058                           timeout_=timeout_,
19059                           check_=check_)
19060
19061    def details(
19062        self,
19063        *,
19064        problem_alias: str,
19065        contest_alias: Optional[str] = None,
19066        lang: Optional[str] = None,
19067        prevent_problemset_open: Optional[bool] = None,
19068        problemset_id: Optional[int] = None,
19069        show_solvers: Optional[bool] = None,
19070        statement_type: Optional[str] = None,
19071        # Out-of-band parameters:
19072        files_: Optional[Mapping[str, BinaryIO]] = None,
19073        check_: bool = True,
19074        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
19075    ) -> ProblemDetailsResponse:
19076        r"""Entry point for Problem Details API
19077
19078        Args:
19079            problem_alias:
19080            contest_alias:
19081            lang:
19082            prevent_problemset_open:
19083            problemset_id:
19084            show_solvers:
19085            statement_type:
19086
19087        Returns:
19088            The API result object.
19089        """
19090        parameters: Dict[str, str] = {
19091            'problem_alias': problem_alias,
19092        }
19093        if contest_alias is not None:
19094            parameters['contest_alias'] = contest_alias
19095        if lang is not None:
19096            parameters['lang'] = lang
19097        if prevent_problemset_open is not None:
19098            parameters['prevent_problemset_open'] = str(
19099                prevent_problemset_open)
19100        if problemset_id is not None:
19101            parameters['problemset_id'] = str(problemset_id)
19102        if show_solvers is not None:
19103            parameters['show_solvers'] = str(show_solvers)
19104        if statement_type is not None:
19105            parameters['statement_type'] = statement_type
19106        return _ProblemDetails(**self._client.query('/api/problem/details/',
19107                                                    payload=parameters,
19108                                                    files_=files_,
19109                                                    timeout_=timeout_,
19110                                                    check_=check_))
19111
19112    def solution(
19113        self,
19114        *,
19115        contest_alias: Optional[str] = None,
19116        forfeit_problem: Optional[bool] = None,
19117        lang: Optional[str] = None,
19118        problem_alias: Optional[str] = None,
19119        problemset_id: Optional[Any] = None,
19120        statement_type: Optional[str] = None,
19121        # Out-of-band parameters:
19122        files_: Optional[Mapping[str, BinaryIO]] = None,
19123        check_: bool = True,
19124        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
19125    ) -> ProblemSolutionResponse:
19126        r"""Returns the solution for a problem if conditions are satisfied.
19127
19128        Args:
19129            contest_alias:
19130            forfeit_problem:
19131            lang:
19132            problem_alias:
19133            problemset_id:
19134            statement_type:
19135
19136        Returns:
19137            The API result object.
19138        """
19139        parameters: Dict[str, str] = {}
19140        if contest_alias is not None:
19141            parameters['contest_alias'] = contest_alias
19142        if forfeit_problem is not None:
19143            parameters['forfeit_problem'] = str(forfeit_problem)
19144        if lang is not None:
19145            parameters['lang'] = lang
19146        if problem_alias is not None:
19147            parameters['problem_alias'] = problem_alias
19148        if problemset_id is not None:
19149            parameters['problemset_id'] = str(problemset_id)
19150        if statement_type is not None:
19151            parameters['statement_type'] = statement_type
19152        return _OmegaUp_Controllers_Problem__apiSolution(
19153            **self._client.query('/api/problem/solution/',
19154                                 payload=parameters,
19155                                 files_=files_,
19156                                 timeout_=timeout_,
19157                                 check_=check_))
19158
19159    def versions(
19160        self,
19161        *,
19162        problem_alias: Optional[str] = None,
19163        problemset_id: Optional[int] = None,
19164        # Out-of-band parameters:
19165        files_: Optional[Mapping[str, BinaryIO]] = None,
19166        check_: bool = True,
19167        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
19168    ) -> ProblemVersionsResponse:
19169        r"""Entry point for Problem Versions API
19170
19171        Args:
19172            problem_alias:
19173            problemset_id:
19174
19175        Returns:
19176            The API result object.
19177        """
19178        parameters: Dict[str, str] = {}
19179        if problem_alias is not None:
19180            parameters['problem_alias'] = problem_alias
19181        if problemset_id is not None:
19182            parameters['problemset_id'] = str(problemset_id)
19183        return _OmegaUp_Controllers_Problem__apiVersions(
19184            **self._client.query('/api/problem/versions/',
19185                                 payload=parameters,
19186                                 files_=files_,
19187                                 timeout_=timeout_,
19188                                 check_=check_))
19189
19190    def selectVersion(
19191            self,
19192            *,
19193            commit: Optional[str] = None,
19194            problem_alias: Optional[str] = None,
19195            update_published: Optional[str] = None,
19196            # Out-of-band parameters:
19197            files_: Optional[Mapping[str, BinaryIO]] = None,
19198            check_: bool = True,
19199            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
19200        r"""Change the version of the problem.
19201
19202        Args:
19203            commit:
19204            problem_alias:
19205            update_published:
19206
19207        Returns:
19208            The API result object.
19209        """
19210        parameters: Dict[str, str] = {}
19211        if commit is not None:
19212            parameters['commit'] = commit
19213        if problem_alias is not None:
19214            parameters['problem_alias'] = problem_alias
19215        if update_published is not None:
19216            parameters['update_published'] = update_published
19217        self._client.query('/api/problem/selectVersion/',
19218                           payload=parameters,
19219                           files_=files_,
19220                           timeout_=timeout_,
19221                           check_=check_)
19222
19223    def runsDiff(
19224        self,
19225        *,
19226        version: str,
19227        problem_alias: Optional[str] = None,
19228        # Out-of-band parameters:
19229        files_: Optional[Mapping[str, BinaryIO]] = None,
19230        check_: bool = True,
19231        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
19232    ) -> ProblemRunsDiffResponse:
19233        r"""Return a report of which runs would change due to a version change.
19234
19235        Args:
19236            version:
19237            problem_alias:
19238
19239        Returns:
19240            The API result object.
19241        """
19242        parameters: Dict[str, str] = {
19243            'version': version,
19244        }
19245        if problem_alias is not None:
19246            parameters['problem_alias'] = problem_alias
19247        return _OmegaUp_Controllers_Problem__apiRunsDiff(
19248            **self._client.query('/api/problem/runsDiff/',
19249                                 payload=parameters,
19250                                 files_=files_,
19251                                 timeout_=timeout_,
19252                                 check_=check_))
19253
19254    def runs(
19255        self,
19256        *,
19257        language: Optional[str] = None,
19258        offset: Optional[int] = None,
19259        problem_alias: Optional[str] = None,
19260        rowcount: Optional[int] = None,
19261        show_all: Optional[bool] = None,
19262        status: Optional[str] = None,
19263        username: Optional[str] = None,
19264        verdict: Optional[str] = None,
19265        # Out-of-band parameters:
19266        files_: Optional[Mapping[str, BinaryIO]] = None,
19267        check_: bool = True,
19268        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
19269    ) -> ProblemRunsResponse:
19270        r"""Entry point for Problem runs API
19271
19272        Args:
19273            language:
19274            offset:
19275            problem_alias:
19276            rowcount:
19277            show_all:
19278            status:
19279            username:
19280            verdict:
19281
19282        Returns:
19283            The API result object.
19284        """
19285        parameters: Dict[str, str] = {}
19286        if language is not None:
19287            parameters['language'] = language
19288        if offset is not None:
19289            parameters['offset'] = str(offset)
19290        if problem_alias is not None:
19291            parameters['problem_alias'] = problem_alias
19292        if rowcount is not None:
19293            parameters['rowcount'] = str(rowcount)
19294        if show_all is not None:
19295            parameters['show_all'] = str(show_all)
19296        if status is not None:
19297            parameters['status'] = status
19298        if username is not None:
19299            parameters['username'] = username
19300        if verdict is not None:
19301            parameters['verdict'] = verdict
19302        return _OmegaUp_Controllers_Problem__apiRuns(
19303            **self._client.query('/api/problem/runs/',
19304                                 payload=parameters,
19305                                 files_=files_,
19306                                 timeout_=timeout_,
19307                                 check_=check_))
19308
19309    def clarifications(
19310        self,
19311        *,
19312        problem_alias: str,
19313        offset: Optional[int] = None,
19314        rowcount: Optional[int] = None,
19315        # Out-of-band parameters:
19316        files_: Optional[Mapping[str, BinaryIO]] = None,
19317        check_: bool = True,
19318        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
19319    ) -> ProblemClarificationsResponse:
19320        r"""Entry point for Problem clarifications API
19321
19322        Args:
19323            problem_alias:
19324            offset:
19325            rowcount:
19326
19327        Returns:
19328            The API result object.
19329        """
19330        parameters: Dict[str, str] = {
19331            'problem_alias': problem_alias,
19332        }
19333        if offset is not None:
19334            parameters['offset'] = str(offset)
19335        if rowcount is not None:
19336            parameters['rowcount'] = str(rowcount)
19337        return _OmegaUp_Controllers_Problem__apiClarifications(
19338            **self._client.query('/api/problem/clarifications/',
19339                                 payload=parameters,
19340                                 files_=files_,
19341                                 timeout_=timeout_,
19342                                 check_=check_))
19343
19344    def stats(
19345        self,
19346        *,
19347        problem_alias: str,
19348        # Out-of-band parameters:
19349        files_: Optional[Mapping[str, BinaryIO]] = None,
19350        check_: bool = True,
19351        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
19352    ) -> ProblemStatsResponse:
19353        r"""Stats of a problem
19354
19355        Args:
19356            problem_alias:
19357
19358        Returns:
19359            The API result object.
19360        """
19361        parameters: Dict[str, str] = {
19362            'problem_alias': problem_alias,
19363        }
19364        return _OmegaUp_Controllers_Problem__apiStats(
19365            **self._client.query('/api/problem/stats/',
19366                                 payload=parameters,
19367                                 files_=files_,
19368                                 timeout_=timeout_,
19369                                 check_=check_))
19370
19371    def listForTypeahead(
19372        self,
19373        *,
19374        query: str,
19375        search_type: str,
19376        offset: Optional[int] = None,
19377        rowcount: Optional[int] = None,
19378        # Out-of-band parameters:
19379        files_: Optional[Mapping[str, BinaryIO]] = None,
19380        check_: bool = True,
19381        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
19382    ) -> ProblemListForTypeaheadResponse:
19383        r"""List of public problems shown in the typeahead component
19384
19385        Args:
19386            query:
19387            search_type:
19388            offset:
19389            rowcount:
19390
19391        Returns:
19392            The API result object.
19393        """
19394        parameters: Dict[str, str] = {
19395            'query': query,
19396            'search_type': search_type,
19397        }
19398        if offset is not None:
19399            parameters['offset'] = str(offset)
19400        if rowcount is not None:
19401            parameters['rowcount'] = str(rowcount)
19402        return _OmegaUp_Controllers_Problem__apiListForTypeahead(
19403            **self._client.query('/api/problem/listForTypeahead/',
19404                                 payload=parameters,
19405                                 files_=files_,
19406                                 timeout_=timeout_,
19407                                 check_=check_))
19408
19409    def list(
19410        self,
19411        *,
19412        only_quality_seal: bool,
19413        difficulty: Optional[str] = None,
19414        difficulty_range: Optional[str] = None,
19415        language: Optional[Any] = None,
19416        level: Optional[str] = None,
19417        max_difficulty: Optional[int] = None,
19418        min_difficulty: Optional[int] = None,
19419        min_visibility: Optional[int] = None,
19420        offset: Optional[int] = None,
19421        only_karel: Optional[Any] = None,
19422        order_by: Optional[Any] = None,
19423        page: Optional[int] = None,
19424        programming_languages: Optional[str] = None,
19425        query: Optional[str] = None,
19426        require_all_tags: Optional[Any] = None,
19427        rowcount: Optional[int] = None,
19428        some_tags: Optional[Any] = None,
19429        sort_order: Optional[Any] = None,
19430        # Out-of-band parameters:
19431        files_: Optional[Mapping[str, BinaryIO]] = None,
19432        check_: bool = True,
19433        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
19434    ) -> ProblemListResponse:
19435        r"""List of public and user's private problems
19436
19437        Args:
19438            only_quality_seal:
19439            difficulty:
19440            difficulty_range:
19441            language:
19442            level:
19443            max_difficulty:
19444            min_difficulty:
19445            min_visibility:
19446            offset:
19447            only_karel:
19448            order_by:
19449            page:
19450            programming_languages:
19451            query:
19452            require_all_tags:
19453            rowcount:
19454            some_tags:
19455            sort_order:
19456
19457        Returns:
19458            The API result object.
19459        """
19460        parameters: Dict[str, str] = {
19461            'only_quality_seal': str(only_quality_seal),
19462        }
19463        if difficulty is not None:
19464            parameters['difficulty'] = difficulty
19465        if difficulty_range is not None:
19466            parameters['difficulty_range'] = difficulty_range
19467        if language is not None:
19468            parameters['language'] = str(language)
19469        if level is not None:
19470            parameters['level'] = level
19471        if max_difficulty is not None:
19472            parameters['max_difficulty'] = str(max_difficulty)
19473        if min_difficulty is not None:
19474            parameters['min_difficulty'] = str(min_difficulty)
19475        if min_visibility is not None:
19476            parameters['min_visibility'] = str(min_visibility)
19477        if offset is not None:
19478            parameters['offset'] = str(offset)
19479        if only_karel is not None:
19480            parameters['only_karel'] = str(only_karel)
19481        if order_by is not None:
19482            parameters['order_by'] = str(order_by)
19483        if page is not None:
19484            parameters['page'] = str(page)
19485        if programming_languages is not None:
19486            parameters['programming_languages'] = programming_languages
19487        if query is not None:
19488            parameters['query'] = query
19489        if require_all_tags is not None:
19490            parameters['require_all_tags'] = str(require_all_tags)
19491        if rowcount is not None:
19492            parameters['rowcount'] = str(rowcount)
19493        if some_tags is not None:
19494            parameters['some_tags'] = str(some_tags)
19495        if sort_order is not None:
19496            parameters['sort_order'] = str(sort_order)
19497        return _OmegaUp_Controllers_Problem__apiList(
19498            **self._client.query('/api/problem/list/',
19499                                 payload=parameters,
19500                                 files_=files_,
19501                                 timeout_=timeout_,
19502                                 check_=check_))
19503
19504    def adminList(
19505        self,
19506        *,
19507        page: int,
19508        page_size: int,
19509        query: Optional[str] = None,
19510        # Out-of-band parameters:
19511        files_: Optional[Mapping[str, BinaryIO]] = None,
19512        check_: bool = True,
19513        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
19514    ) -> ProblemAdminListResponse:
19515        r"""Returns a list of problems where current user has admin rights (or is
19516        the owner).
19517
19518        Args:
19519            page:
19520            page_size:
19521            query:
19522
19523        Returns:
19524            The API result object.
19525        """
19526        parameters: Dict[str, str] = {
19527            'page': str(page),
19528            'page_size': str(page_size),
19529        }
19530        if query is not None:
19531            parameters['query'] = query
19532        return _OmegaUp_Controllers_Problem__apiAdminList(
19533            **self._client.query('/api/problem/adminList/',
19534                                 payload=parameters,
19535                                 files_=files_,
19536                                 timeout_=timeout_,
19537                                 check_=check_))
19538
19539    def myList(
19540        self,
19541        *,
19542        page: int,
19543        query: Optional[str] = None,
19544        rowcount: Optional[int] = None,
19545        # Out-of-band parameters:
19546        files_: Optional[Mapping[str, BinaryIO]] = None,
19547        check_: bool = True,
19548        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
19549    ) -> ProblemMyListResponse:
19550        r"""Gets a list of problems where current user is the owner
19551
19552        Args:
19553            page:
19554            query:
19555            rowcount:
19556
19557        Returns:
19558            The API result object.
19559        """
19560        parameters: Dict[str, str] = {
19561            'page': str(page),
19562        }
19563        if query is not None:
19564            parameters['query'] = query
19565        if rowcount is not None:
19566            parameters['rowcount'] = str(rowcount)
19567        return _OmegaUp_Controllers_Problem__apiMyList(
19568            **self._client.query('/api/problem/myList/',
19569                                 payload=parameters,
19570                                 files_=files_,
19571                                 timeout_=timeout_,
19572                                 check_=check_))
19573
19574    def bestScore(
19575        self,
19576        *,
19577        contest_alias: Optional[str] = None,
19578        problem_alias: Optional[str] = None,
19579        problemset_id: Optional[Any] = None,
19580        statement_type: Optional[str] = None,
19581        username: Optional[str] = None,
19582        # Out-of-band parameters:
19583        files_: Optional[Mapping[str, BinaryIO]] = None,
19584        check_: bool = True,
19585        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
19586    ) -> ProblemBestScoreResponse:
19587        r"""Returns the best score for a problem
19588
19589        Args:
19590            contest_alias:
19591            problem_alias:
19592            problemset_id:
19593            statement_type:
19594            username:
19595
19596        Returns:
19597            The API result object.
19598        """
19599        parameters: Dict[str, str] = {}
19600        if contest_alias is not None:
19601            parameters['contest_alias'] = contest_alias
19602        if problem_alias is not None:
19603            parameters['problem_alias'] = problem_alias
19604        if problemset_id is not None:
19605            parameters['problemset_id'] = str(problemset_id)
19606        if statement_type is not None:
19607            parameters['statement_type'] = statement_type
19608        if username is not None:
19609            parameters['username'] = username
19610        return _OmegaUp_Controllers_Problem__apiBestScore(
19611            **self._client.query('/api/problem/bestScore/',
19612                                 payload=parameters,
19613                                 files_=files_,
19614                                 timeout_=timeout_,
19615                                 check_=check_))
19616
19617    def randomLanguageProblem(
19618        self,
19619        *,
19620        # Out-of-band parameters:
19621        files_: Optional[Mapping[str, BinaryIO]] = None,
19622        check_: bool = True,
19623        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
19624    ) -> ProblemRandomLanguageProblemResponse:
19625        r"""
19626
19627        Returns:
19628            The API result object.
19629        """
19630        parameters: Dict[str, str] = {}
19631        return _OmegaUp_Controllers_Problem__apiRandomLanguageProblem(
19632            **self._client.query('/api/problem/randomLanguageProblem/',
19633                                 payload=parameters,
19634                                 files_=files_,
19635                                 timeout_=timeout_,
19636                                 check_=check_))
19637
19638    def randomKarelProblem(
19639        self,
19640        *,
19641        # Out-of-band parameters:
19642        files_: Optional[Mapping[str, BinaryIO]] = None,
19643        check_: bool = True,
19644        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
19645    ) -> ProblemRandomKarelProblemResponse:
19646        r"""
19647
19648        Returns:
19649            The API result object.
19650        """
19651        parameters: Dict[str, str] = {}
19652        return _OmegaUp_Controllers_Problem__apiRandomKarelProblem(
19653            **self._client.query('/api/problem/randomKarelProblem/',
19654                                 payload=parameters,
19655                                 files_=files_,
19656                                 timeout_=timeout_,
19657                                 check_=check_))
19658
19659
19660ProblemForfeitedGetCountsResponse = _OmegaUp_Controllers_ProblemForfeited__apiGetCounts
19661"""The return type of the ProblemForfeitedGetCounts API."""
19662
19663
19664class ProblemForfeited:
19665    r"""ProblemForfeitedController
19666    """
19667    def __init__(self, client: 'Client') -> None:
19668        self._client = client
19669
19670    def getCounts(
19671        self,
19672        *,
19673        # Out-of-band parameters:
19674        files_: Optional[Mapping[str, BinaryIO]] = None,
19675        check_: bool = True,
19676        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
19677    ) -> ProblemForfeitedGetCountsResponse:
19678        r"""Returns the number of solutions allowed
19679        and the number of solutions already seen
19680
19681        Returns:
19682            The API result object.
19683        """
19684        parameters: Dict[str, str] = {}
19685        return _OmegaUp_Controllers_ProblemForfeited__apiGetCounts(
19686            **self._client.query('/api/problemForfeited/getCounts/',
19687                                 payload=parameters,
19688                                 files_=files_,
19689                                 timeout_=timeout_,
19690                                 check_=check_))
19691
19692
19693ProblemsetDetailsResponse = _Problemset
19694"""The return type of the ProblemsetDetails API."""
19695
19696ProblemsetScoreboardResponse = _Scoreboard
19697"""The return type of the ProblemsetScoreboard API."""
19698
19699ProblemsetScoreboardEventsResponse = _OmegaUp_Controllers_Problemset__apiScoreboardEvents
19700"""The return type of the ProblemsetScoreboardEvents API."""
19701
19702
19703class Problemset:
19704    r"""
19705    """
19706    def __init__(self, client: 'Client') -> None:
19707        self._client = client
19708
19709    def details(
19710        self,
19711        *,
19712        assignment: str,
19713        contest_alias: str,
19714        course: str,
19715        problemset_id: int,
19716        auth_token: Optional[Any] = None,
19717        token: Optional[str] = None,
19718        tokens: Optional[Any] = None,
19719        # Out-of-band parameters:
19720        files_: Optional[Mapping[str, BinaryIO]] = None,
19721        check_: bool = True,
19722        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
19723    ) -> ProblemsetDetailsResponse:
19724        r"""
19725
19726        Args:
19727            assignment:
19728            contest_alias:
19729            course:
19730            problemset_id:
19731            auth_token:
19732            token:
19733            tokens:
19734
19735        Returns:
19736            The API result object.
19737        """
19738        parameters: Dict[str, str] = {
19739            'assignment': assignment,
19740            'contest_alias': contest_alias,
19741            'course': course,
19742            'problemset_id': str(problemset_id),
19743        }
19744        if auth_token is not None:
19745            parameters['auth_token'] = str(auth_token)
19746        if token is not None:
19747            parameters['token'] = token
19748        if tokens is not None:
19749            parameters['tokens'] = str(tokens)
19750        return _Problemset(**self._client.query('/api/problemset/details/',
19751                                                payload=parameters,
19752                                                files_=files_,
19753                                                timeout_=timeout_,
19754                                                check_=check_))
19755
19756    def scoreboard(
19757        self,
19758        *,
19759        assignment: str,
19760        contest_alias: str,
19761        course: str,
19762        problemset_id: int,
19763        auth_token: Optional[Any] = None,
19764        token: Optional[Any] = None,
19765        tokens: Optional[Any] = None,
19766        # Out-of-band parameters:
19767        files_: Optional[Mapping[str, BinaryIO]] = None,
19768        check_: bool = True,
19769        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
19770    ) -> ProblemsetScoreboardResponse:
19771        r"""
19772
19773        Args:
19774            assignment:
19775            contest_alias:
19776            course:
19777            problemset_id:
19778            auth_token:
19779            token:
19780            tokens:
19781
19782        Returns:
19783            The API result object.
19784        """
19785        parameters: Dict[str, str] = {
19786            'assignment': assignment,
19787            'contest_alias': contest_alias,
19788            'course': course,
19789            'problemset_id': str(problemset_id),
19790        }
19791        if auth_token is not None:
19792            parameters['auth_token'] = str(auth_token)
19793        if token is not None:
19794            parameters['token'] = str(token)
19795        if tokens is not None:
19796            parameters['tokens'] = str(tokens)
19797        return _Scoreboard(**self._client.query('/api/problemset/scoreboard/',
19798                                                payload=parameters,
19799                                                files_=files_,
19800                                                timeout_=timeout_,
19801                                                check_=check_))
19802
19803    def scoreboardEvents(
19804        self,
19805        *,
19806        assignment: str,
19807        contest_alias: str,
19808        course: str,
19809        problemset_id: int,
19810        auth_token: Optional[Any] = None,
19811        token: Optional[Any] = None,
19812        tokens: Optional[Any] = None,
19813        # Out-of-band parameters:
19814        files_: Optional[Mapping[str, BinaryIO]] = None,
19815        check_: bool = True,
19816        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
19817    ) -> ProblemsetScoreboardEventsResponse:
19818        r"""Returns the Scoreboard events
19819
19820        Args:
19821            assignment:
19822            contest_alias:
19823            course:
19824            problemset_id:
19825            auth_token:
19826            token:
19827            tokens:
19828
19829        Returns:
19830            The API result object.
19831        """
19832        parameters: Dict[str, str] = {
19833            'assignment': assignment,
19834            'contest_alias': contest_alias,
19835            'course': course,
19836            'problemset_id': str(problemset_id),
19837        }
19838        if auth_token is not None:
19839            parameters['auth_token'] = str(auth_token)
19840        if token is not None:
19841            parameters['token'] = str(token)
19842        if tokens is not None:
19843            parameters['tokens'] = str(tokens)
19844        return _OmegaUp_Controllers_Problemset__apiScoreboardEvents(
19845            **self._client.query('/api/problemset/scoreboardEvents/',
19846                                 payload=parameters,
19847                                 files_=files_,
19848                                 timeout_=timeout_,
19849                                 check_=check_))
19850
19851
19852QualityNominationCreateResponse = _OmegaUp_Controllers_QualityNomination__apiCreate
19853"""The return type of the QualityNominationCreate API."""
19854
19855QualityNominationListResponse = _OmegaUp_Controllers_QualityNomination__apiList
19856"""The return type of the QualityNominationList API."""
19857
19858QualityNominationMyAssignedListResponse = _OmegaUp_Controllers_QualityNomination__apiMyAssignedList
19859"""The return type of the QualityNominationMyAssignedList API."""
19860
19861QualityNominationMyListResponse = _OmegaUp_Controllers_QualityNomination__apiMyList
19862"""The return type of the QualityNominationMyList API."""
19863
19864QualityNominationDetailsResponse = _OmegaUp_Controllers_QualityNomination__apiDetails
19865"""The return type of the QualityNominationDetails API."""
19866
19867
19868class QualityNomination:
19869    r"""QualityNominationController
19870    """
19871    def __init__(self, client: 'Client') -> None:
19872        self._client = client
19873
19874    def create(
19875        self,
19876        *,
19877        contents: str,
19878        nomination: str,
19879        problem_alias: str,
19880        # Out-of-band parameters:
19881        files_: Optional[Mapping[str, BinaryIO]] = None,
19882        check_: bool = True,
19883        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
19884    ) -> QualityNominationCreateResponse:
19885        r"""Creates a new QualityNomination
19886
19887        There are three ways in which users can interact with this:
19888
19889        # Suggestion
19890
19891        A user that has already solved a problem can make suggestions about a
19892        problem. This expects the `nomination` field to be `suggestion` and the
19893        `contents` field should be a JSON blob with at least one the following fields:
19894
19895        * `difficulty`: (Optional) A number in the range [0-4] indicating the
19896                        difficulty of the problem.
19897        * `quality`: (Optional) A number in the range [0-4] indicating the quality
19898                    of the problem.
19899        * `tags`: (Optional) An array of tag names that will be added to the
19900                  problem upon promotion.
19901        * `before_ac`: (Optional) Boolean indicating if the suggestion has been sent
19902                       before receiving an AC verdict for problem run.
19903
19904        # Quality tag
19905
19906        A reviewer could send this type of nomination to make the user marked as
19907        a quality problem or not. The reviewer could also specify which category
19908        is the one the problem belongs to. The 'contents' field should have the
19909        following subfields:
19910
19911        * tag: The name of the tag corresponding to the category of the problem
19912        * quality_seal: A boolean that if activated, means that the problem is a
19913          quality problem
19914
19915        # Promotion
19916
19917        A user that has already solved a problem can nominate it to be promoted
19918        as a Quality Problem. This expects the `nomination` field to be
19919        `promotion` and the `contents` field should be a JSON blob with the
19920        following fields:
19921
19922        * `statements`: A dictionary of languages to objects that contain a
19923                        `markdown` field, which is the markdown-formatted
19924                        problem statement for that language.
19925        * `source`: A URL or string clearly documenting the source or full name
19926                    of original author of the problem.
19927        * `tags`: An array of tag names that will be added to the problem upon
19928                  promotion.
19929
19930        # Demotion
19931
19932        A demoted problem is banned, and cannot be un-banned or added to any new
19933        problemsets. This expects the `nomination` field to be `demotion` and
19934        the `contents` field should be a JSON blob with the following fields:
19935
19936        * `rationale`: A small text explaining the rationale for demotion.
19937        * `reason`: One of `['duplicate', 'no-problem-statement', 'offensive', 'other', 'spam']`.
19938        * `original`: If the `reason` is `duplicate`, the alias of the original
19939                      problem.
19940        # Dismissal
19941        A user that has already solved a problem can dismiss suggestions. The
19942        `contents` field is empty.
19943
19944        Args:
19945            contents:
19946            nomination:
19947            problem_alias:
19948
19949        Returns:
19950            The API result object.
19951        """
19952        parameters: Dict[str, str] = {
19953            'contents': contents,
19954            'nomination': nomination,
19955            'problem_alias': problem_alias,
19956        }
19957        return _OmegaUp_Controllers_QualityNomination__apiCreate(
19958            **self._client.query('/api/qualityNomination/create/',
19959                                 payload=parameters,
19960                                 files_=files_,
19961                                 timeout_=timeout_,
19962                                 check_=check_))
19963
19964    def resolve(
19965            self,
19966            *,
19967            problem_alias: str,
19968            qualitynomination_id: int,
19969            rationale: str,
19970            status: str,
19971            all: Optional[bool] = None,
19972            # Out-of-band parameters:
19973            files_: Optional[Mapping[str, BinaryIO]] = None,
19974            check_: bool = True,
19975            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
19976        r"""Marks a problem of a nomination (only the demotion type supported for now) as (resolved, banned, warning).
19977
19978        Args:
19979            problem_alias:
19980            qualitynomination_id:
19981            rationale:
19982            status:
19983            all:
19984
19985        Returns:
19986            The API result object.
19987        """
19988        parameters: Dict[str, str] = {
19989            'problem_alias': problem_alias,
19990            'qualitynomination_id': str(qualitynomination_id),
19991            'rationale': rationale,
19992            'status': status,
19993        }
19994        if all is not None:
19995            parameters['all'] = str(all)
19996        self._client.query('/api/qualityNomination/resolve/',
19997                           payload=parameters,
19998                           files_=files_,
19999                           timeout_=timeout_,
20000                           check_=check_)
20001
20002    def list(
20003        self,
20004        *,
20005        offset: int,
20006        rowcount: int,
20007        column: Optional[str] = None,
20008        query: Optional[str] = None,
20009        status: Optional[Any] = None,
20010        # Out-of-band parameters:
20011        files_: Optional[Mapping[str, BinaryIO]] = None,
20012        check_: bool = True,
20013        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
20014    ) -> QualityNominationListResponse:
20015        r"""
20016
20017        Args:
20018            offset:
20019            rowcount:
20020            column:
20021            query:
20022            status:
20023
20024        Returns:
20025            The API result object.
20026        """
20027        parameters: Dict[str, str] = {
20028            'offset': str(offset),
20029            'rowcount': str(rowcount),
20030        }
20031        if column is not None:
20032            parameters['column'] = column
20033        if query is not None:
20034            parameters['query'] = query
20035        if status is not None:
20036            parameters['status'] = str(status)
20037        return _OmegaUp_Controllers_QualityNomination__apiList(
20038            **self._client.query('/api/qualityNomination/list/',
20039                                 payload=parameters,
20040                                 files_=files_,
20041                                 timeout_=timeout_,
20042                                 check_=check_))
20043
20044    def myAssignedList(
20045        self,
20046        *,
20047        page: int,
20048        page_size: int,
20049        # Out-of-band parameters:
20050        files_: Optional[Mapping[str, BinaryIO]] = None,
20051        check_: bool = True,
20052        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
20053    ) -> QualityNominationMyAssignedListResponse:
20054        r"""Displays the nominations that this user has been assigned.
20055
20056        Args:
20057            page:
20058            page_size:
20059
20060        Returns:
20061            The API result object.
20062        """
20063        parameters: Dict[str, str] = {
20064            'page': str(page),
20065            'page_size': str(page_size),
20066        }
20067        return _OmegaUp_Controllers_QualityNomination__apiMyAssignedList(
20068            **self._client.query('/api/qualityNomination/myAssignedList/',
20069                                 payload=parameters,
20070                                 files_=files_,
20071                                 timeout_=timeout_,
20072                                 check_=check_))
20073
20074    def myList(
20075        self,
20076        *,
20077        offset: int,
20078        rowcount: int,
20079        # Out-of-band parameters:
20080        files_: Optional[Mapping[str, BinaryIO]] = None,
20081        check_: bool = True,
20082        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
20083    ) -> QualityNominationMyListResponse:
20084        r"""
20085
20086        Args:
20087            offset:
20088            rowcount:
20089
20090        Returns:
20091            The API result object.
20092        """
20093        parameters: Dict[str, str] = {
20094            'offset': str(offset),
20095            'rowcount': str(rowcount),
20096        }
20097        return _OmegaUp_Controllers_QualityNomination__apiMyList(
20098            **self._client.query('/api/qualityNomination/myList/',
20099                                 payload=parameters,
20100                                 files_=files_,
20101                                 timeout_=timeout_,
20102                                 check_=check_))
20103
20104    def details(
20105        self,
20106        *,
20107        qualitynomination_id: int,
20108        # Out-of-band parameters:
20109        files_: Optional[Mapping[str, BinaryIO]] = None,
20110        check_: bool = True,
20111        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
20112    ) -> QualityNominationDetailsResponse:
20113        r"""Displays the details of a nomination. The user needs to be either the
20114        nominator or a member of the reviewer group.
20115
20116        Args:
20117            qualitynomination_id:
20118
20119        Returns:
20120            The API result object.
20121        """
20122        parameters: Dict[str, str] = {
20123            'qualitynomination_id': str(qualitynomination_id),
20124        }
20125        return _OmegaUp_Controllers_QualityNomination__apiDetails(
20126            **self._client.query('/api/qualityNomination/details/',
20127                                 payload=parameters,
20128                                 files_=files_,
20129                                 timeout_=timeout_,
20130                                 check_=check_))
20131
20132
20133ResetCreateResponse = _OmegaUp_Controllers_Reset__apiCreate
20134"""The return type of the ResetCreate API."""
20135
20136ResetGenerateTokenResponse = _OmegaUp_Controllers_Reset__apiGenerateToken
20137"""The return type of the ResetGenerateToken API."""
20138
20139ResetUpdateResponse = _OmegaUp_Controllers_Reset__apiUpdate
20140"""The return type of the ResetUpdate API."""
20141
20142
20143class Reset:
20144    r"""
20145    """
20146    def __init__(self, client: 'Client') -> None:
20147        self._client = client
20148
20149    def create(
20150        self,
20151        *,
20152        email: str,
20153        # Out-of-band parameters:
20154        files_: Optional[Mapping[str, BinaryIO]] = None,
20155        check_: bool = True,
20156        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
20157    ) -> ResetCreateResponse:
20158        r"""Creates a reset operation, the first of two steps needed to reset a
20159        password. The first step consist of sending an email to the user with
20160        instructions to reset he's password, if and only if the email is valid.
20161
20162        Args:
20163            email:
20164
20165        Returns:
20166            The API result object.
20167        """
20168        parameters: Dict[str, str] = {
20169            'email': email,
20170        }
20171        return _OmegaUp_Controllers_Reset__apiCreate(
20172            **self._client.query('/api/reset/create/',
20173                                 payload=parameters,
20174                                 files_=files_,
20175                                 timeout_=timeout_,
20176                                 check_=check_))
20177
20178    def generateToken(
20179        self,
20180        *,
20181        email: str,
20182        # Out-of-band parameters:
20183        files_: Optional[Mapping[str, BinaryIO]] = None,
20184        check_: bool = True,
20185        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
20186    ) -> ResetGenerateTokenResponse:
20187        r"""Creates a reset operation, support team members can generate a valid
20188        token and then they can send it to end user
20189
20190        Args:
20191            email:
20192
20193        Returns:
20194            The API result object.
20195        """
20196        parameters: Dict[str, str] = {
20197            'email': email,
20198        }
20199        return _OmegaUp_Controllers_Reset__apiGenerateToken(
20200            **self._client.query('/api/reset/generateToken/',
20201                                 payload=parameters,
20202                                 files_=files_,
20203                                 timeout_=timeout_,
20204                                 check_=check_))
20205
20206    def update(
20207        self,
20208        *,
20209        email: str,
20210        password: str,
20211        password_confirmation: str,
20212        reset_token: str,
20213        # Out-of-band parameters:
20214        files_: Optional[Mapping[str, BinaryIO]] = None,
20215        check_: bool = True,
20216        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
20217    ) -> ResetUpdateResponse:
20218        r"""Updates the password of a given user, this is the second and last step
20219        in order to reset the password. This operation is done if and only if
20220        the correct parameters are suplied.
20221
20222        Args:
20223            email:
20224            password:
20225            password_confirmation:
20226            reset_token:
20227
20228        Returns:
20229            The API result object.
20230        """
20231        parameters: Dict[str, str] = {
20232            'email': email,
20233            'password': password,
20234            'password_confirmation': password_confirmation,
20235            'reset_token': reset_token,
20236        }
20237        return _OmegaUp_Controllers_Reset__apiUpdate(
20238            **self._client.query('/api/reset/update/',
20239                                 payload=parameters,
20240                                 files_=files_,
20241                                 timeout_=timeout_,
20242                                 check_=check_))
20243
20244
20245RunCreateResponse = _OmegaUp_Controllers_Run__apiCreate
20246"""The return type of the RunCreate API."""
20247
20248RunStatusResponse = _Run
20249"""The return type of the RunStatus API."""
20250
20251RunDetailsResponse = _RunDetails
20252"""The return type of the RunDetails API."""
20253
20254RunSourceResponse = _OmegaUp_Controllers_Run__apiSource
20255"""The return type of the RunSource API."""
20256
20257RunCountsResponse = _OmegaUp_Controllers_Run__apiCounts
20258"""The return type of the RunCounts API."""
20259
20260RunListResponse = _OmegaUp_Controllers_Run__apiList
20261"""The return type of the RunList API."""
20262
20263
20264class Run:
20265    r"""RunController
20266    """
20267    def __init__(self, client: 'Client') -> None:
20268        self._client = client
20269
20270    def create(
20271            self,
20272            *,
20273            contest_alias: str,
20274            language: str,
20275            problem_alias: str,
20276            source: str,
20277            problemset_id: Optional[Any] = None,
20278            # Out-of-band parameters:
20279            files_: Optional[Mapping[str, BinaryIO]] = None,
20280            check_: bool = True,
20281            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
20282    ) -> RunCreateResponse:
20283        r"""Create a new run
20284
20285        Args:
20286            contest_alias:
20287            language:
20288            problem_alias:
20289            source:
20290            problemset_id:
20291
20292        Returns:
20293            The API result object.
20294        """
20295        parameters: Dict[str, str] = {
20296            'contest_alias': contest_alias,
20297            'language': language,
20298            'problem_alias': problem_alias,
20299            'source': source,
20300        }
20301        if problemset_id is not None:
20302            parameters['problemset_id'] = str(problemset_id)
20303        return _OmegaUp_Controllers_Run__apiCreate(
20304            **self._client.query('/api/run/create/',
20305                                 payload=parameters,
20306                                 files_=files_,
20307                                 timeout_=timeout_,
20308                                 check_=check_))
20309
20310    def status(
20311            self,
20312            *,
20313            run_alias: str,
20314            # Out-of-band parameters:
20315            files_: Optional[Mapping[str, BinaryIO]] = None,
20316            check_: bool = True,
20317            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
20318    ) -> RunStatusResponse:
20319        r"""Get basic details of a run
20320
20321        Args:
20322            run_alias:
20323
20324        Returns:
20325            The API result object.
20326        """
20327        parameters: Dict[str, str] = {
20328            'run_alias': run_alias,
20329        }
20330        return _Run(**self._client.query('/api/run/status/',
20331                                         payload=parameters,
20332                                         files_=files_,
20333                                         timeout_=timeout_,
20334                                         check_=check_))
20335
20336    def rejudge(
20337            self,
20338            *,
20339            run_alias: str,
20340            debug: Optional[bool] = None,
20341            # Out-of-band parameters:
20342            files_: Optional[Mapping[str, BinaryIO]] = None,
20343            check_: bool = True,
20344            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
20345        r"""Re-sends a problem to Grader.
20346
20347        Args:
20348            run_alias:
20349            debug:
20350
20351        Returns:
20352            The API result object.
20353        """
20354        parameters: Dict[str, str] = {
20355            'run_alias': run_alias,
20356        }
20357        if debug is not None:
20358            parameters['debug'] = str(debug)
20359        self._client.query('/api/run/rejudge/',
20360                           payload=parameters,
20361                           files_=files_,
20362                           timeout_=timeout_,
20363                           check_=check_)
20364
20365    def disqualify(
20366            self,
20367            *,
20368            run_alias: str,
20369            # Out-of-band parameters:
20370            files_: Optional[Mapping[str, BinaryIO]] = None,
20371            check_: bool = True,
20372            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
20373        r"""Disqualify a submission
20374
20375        Args:
20376            run_alias:
20377
20378        Returns:
20379            The API result object.
20380        """
20381        parameters: Dict[str, str] = {
20382            'run_alias': run_alias,
20383        }
20384        self._client.query('/api/run/disqualify/',
20385                           payload=parameters,
20386                           files_=files_,
20387                           timeout_=timeout_,
20388                           check_=check_)
20389
20390    def requalify(
20391            self,
20392            *,
20393            run_alias: str,
20394            # Out-of-band parameters:
20395            files_: Optional[Mapping[str, BinaryIO]] = None,
20396            check_: bool = True,
20397            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
20398        r"""Requalify a submission previously disqualified
20399
20400        Args:
20401            run_alias:
20402
20403        Returns:
20404            The API result object.
20405        """
20406        parameters: Dict[str, str] = {
20407            'run_alias': run_alias,
20408        }
20409        self._client.query('/api/run/requalify/',
20410                           payload=parameters,
20411                           files_=files_,
20412                           timeout_=timeout_,
20413                           check_=check_)
20414
20415    def details(
20416            self,
20417            *,
20418            run_alias: str,
20419            # Out-of-band parameters:
20420            files_: Optional[Mapping[str, BinaryIO]] = None,
20421            check_: bool = True,
20422            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
20423    ) -> RunDetailsResponse:
20424        r"""Gets the details of a run. Includes admin details if admin.
20425
20426        Args:
20427            run_alias:
20428
20429        Returns:
20430            The API result object.
20431        """
20432        parameters: Dict[str, str] = {
20433            'run_alias': run_alias,
20434        }
20435        return _RunDetails(**self._client.query('/api/run/details/',
20436                                                payload=parameters,
20437                                                files_=files_,
20438                                                timeout_=timeout_,
20439                                                check_=check_))
20440
20441    def source(
20442            self,
20443            *,
20444            run_alias: str,
20445            # Out-of-band parameters:
20446            files_: Optional[Mapping[str, BinaryIO]] = None,
20447            check_: bool = True,
20448            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
20449    ) -> RunSourceResponse:
20450        r"""Given the run alias, returns the source code and any compile errors if any
20451        Used in the arena, any contestant can view its own codes and compile errors
20452
20453        Args:
20454            run_alias:
20455
20456        Returns:
20457            The API result object.
20458        """
20459        parameters: Dict[str, str] = {
20460            'run_alias': run_alias,
20461        }
20462        return _OmegaUp_Controllers_Run__apiSource(
20463            **self._client.query('/api/run/source/',
20464                                 payload=parameters,
20465                                 files_=files_,
20466                                 timeout_=timeout_,
20467                                 check_=check_))
20468
20469    def counts(
20470            self,
20471            *,
20472            # Out-of-band parameters:
20473            files_: Optional[Mapping[str, BinaryIO]] = None,
20474            check_: bool = True,
20475            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
20476    ) -> RunCountsResponse:
20477        r"""Get total of last 6 months
20478
20479        Returns:
20480            The API result object.
20481        """
20482        parameters: Dict[str, str] = {}
20483        return _OmegaUp_Controllers_Run__apiCounts(
20484            **self._client.query('/api/run/counts/',
20485                                 payload=parameters,
20486                                 files_=files_,
20487                                 timeout_=timeout_,
20488                                 check_=check_))
20489
20490    def list(
20491            self,
20492            *,
20493            offset: int,
20494            problem_alias: str,
20495            rowcount: int,
20496            username: str,
20497            language: Optional[str] = None,
20498            status: Optional[str] = None,
20499            verdict: Optional[str] = None,
20500            # Out-of-band parameters:
20501            files_: Optional[Mapping[str, BinaryIO]] = None,
20502            check_: bool = True,
20503            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
20504    ) -> RunListResponse:
20505        r"""Gets a list of latest runs overall
20506
20507        Args:
20508            offset:
20509            problem_alias:
20510            rowcount:
20511            username:
20512            language:
20513            status:
20514            verdict:
20515
20516        Returns:
20517            The API result object.
20518        """
20519        parameters: Dict[str, str] = {
20520            'offset': str(offset),
20521            'problem_alias': problem_alias,
20522            'rowcount': str(rowcount),
20523            'username': username,
20524        }
20525        if language is not None:
20526            parameters['language'] = language
20527        if status is not None:
20528            parameters['status'] = status
20529        if verdict is not None:
20530            parameters['verdict'] = verdict
20531        return _OmegaUp_Controllers_Run__apiList(
20532            **self._client.query('/api/run/list/',
20533                                 payload=parameters,
20534                                 files_=files_,
20535                                 timeout_=timeout_,
20536                                 check_=check_))
20537
20538
20539SchoolListResponse = _OmegaUp_Controllers_School__apiList
20540"""The return type of the SchoolList API."""
20541
20542SchoolCreateResponse = _OmegaUp_Controllers_School__apiCreate
20543"""The return type of the SchoolCreate API."""
20544
20545
20546class School:
20547    r"""SchoolController
20548    """
20549    def __init__(self, client: 'Client') -> None:
20550        self._client = client
20551
20552    def list(
20553            self,
20554            *,
20555            query: Optional[str] = None,
20556            term: Optional[str] = None,
20557            # Out-of-band parameters:
20558            files_: Optional[Mapping[str, BinaryIO]] = None,
20559            check_: bool = True,
20560            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
20561    ) -> SchoolListResponse:
20562        r"""Gets a list of schools
20563
20564        Args:
20565            query:
20566            term:
20567
20568        Returns:
20569            The API result object.
20570        """
20571        parameters: Dict[str, str] = {}
20572        if query is not None:
20573            parameters['query'] = query
20574        if term is not None:
20575            parameters['term'] = term
20576        return _OmegaUp_Controllers_School__apiList(
20577            **self._client.query('/api/school/list/',
20578                                 payload=parameters,
20579                                 files_=files_,
20580                                 timeout_=timeout_,
20581                                 check_=check_))
20582
20583    def create(
20584        self,
20585        *,
20586        name: str,
20587        country_id: Optional[str] = None,
20588        state_id: Optional[str] = None,
20589        # Out-of-band parameters:
20590        files_: Optional[Mapping[str, BinaryIO]] = None,
20591        check_: bool = True,
20592        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
20593    ) -> SchoolCreateResponse:
20594        r"""Api to create new school
20595
20596        Args:
20597            name:
20598            country_id:
20599            state_id:
20600
20601        Returns:
20602            The API result object.
20603        """
20604        parameters: Dict[str, str] = {
20605            'name': name,
20606        }
20607        if country_id is not None:
20608            parameters['country_id'] = country_id
20609        if state_id is not None:
20610            parameters['state_id'] = state_id
20611        return _OmegaUp_Controllers_School__apiCreate(
20612            **self._client.query('/api/school/create/',
20613                                 payload=parameters,
20614                                 files_=files_,
20615                                 timeout_=timeout_,
20616                                 check_=check_))
20617
20618    def selectSchoolOfTheMonth(
20619            self,
20620            *,
20621            school_id: int,
20622            # Out-of-band parameters:
20623            files_: Optional[Mapping[str, BinaryIO]] = None,
20624            check_: bool = True,
20625            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
20626        r"""Selects a certain school as school of the month
20627
20628        Args:
20629            school_id:
20630
20631        Returns:
20632            The API result object.
20633        """
20634        parameters: Dict[str, str] = {
20635            'school_id': str(school_id),
20636        }
20637        self._client.query('/api/school/selectSchoolOfTheMonth/',
20638                           payload=parameters,
20639                           files_=files_,
20640                           timeout_=timeout_,
20641                           check_=check_)
20642
20643
20644class Scoreboard:
20645    r"""ScoreboardController
20646    """
20647    def __init__(self, client: 'Client') -> None:
20648        self._client = client
20649
20650    def refresh(
20651            self,
20652            *,
20653            alias: str,
20654            course_alias: Optional[str] = None,
20655            token: Optional[Any] = None,
20656            # Out-of-band parameters:
20657            files_: Optional[Mapping[str, BinaryIO]] = None,
20658            check_: bool = True,
20659            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
20660        r"""Returns a list of contests
20661
20662        Args:
20663            alias:
20664            course_alias:
20665            token:
20666
20667        Returns:
20668            The API result object.
20669        """
20670        parameters: Dict[str, str] = {
20671            'alias': alias,
20672        }
20673        if course_alias is not None:
20674            parameters['course_alias'] = course_alias
20675        if token is not None:
20676            parameters['token'] = str(token)
20677        self._client.query('/api/scoreboard/refresh/',
20678                           payload=parameters,
20679                           files_=files_,
20680                           timeout_=timeout_,
20681                           check_=check_)
20682
20683
20684SessionCurrentSessionResponse = _OmegaUp_Controllers_Session__apiCurrentSession
20685"""The return type of the SessionCurrentSession API."""
20686
20687SessionGoogleLoginResponse = _OmegaUp_Controllers_Session__apiGoogleLogin
20688"""The return type of the SessionGoogleLogin API."""
20689
20690
20691class Session:
20692    r"""Session controller handles sessions.
20693    """
20694    def __init__(self, client: 'Client') -> None:
20695        self._client = client
20696
20697    def currentSession(
20698        self,
20699        *,
20700        auth_token: Optional[str] = None,
20701        # Out-of-band parameters:
20702        files_: Optional[Mapping[str, BinaryIO]] = None,
20703        check_: bool = True,
20704        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
20705    ) -> SessionCurrentSessionResponse:
20706        r"""Returns information about current session. In order to avoid one full
20707        server roundtrip (about ~100msec on each pageload), it also returns the
20708        current time to be able to calculate the time delta between the
20709        contestant's machine and the server.
20710
20711        Args:
20712            auth_token:
20713
20714        Returns:
20715            The API result object.
20716        """
20717        parameters: Dict[str, str] = {}
20718        if auth_token is not None:
20719            parameters['auth_token'] = auth_token
20720        return _OmegaUp_Controllers_Session__apiCurrentSession(
20721            **self._client.query('/api/session/currentSession/',
20722                                 payload=parameters,
20723                                 files_=files_,
20724                                 timeout_=timeout_,
20725                                 check_=check_))
20726
20727    def googleLogin(
20728        self,
20729        *,
20730        storeToken: str,
20731        # Out-of-band parameters:
20732        files_: Optional[Mapping[str, BinaryIO]] = None,
20733        check_: bool = True,
20734        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
20735    ) -> SessionGoogleLoginResponse:
20736        r"""
20737
20738        Args:
20739            storeToken:
20740
20741        Returns:
20742            The API result object.
20743        """
20744        parameters: Dict[str, str] = {
20745            'storeToken': storeToken,
20746        }
20747        return _OmegaUp_Controllers_Session__apiGoogleLogin(
20748            **self._client.query('/api/session/googleLogin/',
20749                                 payload=parameters,
20750                                 files_=files_,
20751                                 timeout_=timeout_,
20752                                 check_=check_))
20753
20754
20755class Submission:
20756    r"""SubmissionController
20757    """
20758    def __init__(self, client: 'Client') -> None:
20759        self._client = client
20760
20761    def setFeedback(
20762            self,
20763            *,
20764            assignment_alias: str,
20765            course_alias: str,
20766            feedback: str,
20767            guid: str,
20768            range_bytes_end: Optional[int] = None,
20769            range_bytes_start: Optional[int] = None,
20770            # Out-of-band parameters:
20771            files_: Optional[Mapping[str, BinaryIO]] = None,
20772            check_: bool = True,
20773            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
20774        r"""Updates the admin feedback for a submission
20775
20776        Args:
20777            assignment_alias:
20778            course_alias:
20779            feedback:
20780            guid:
20781            range_bytes_end:
20782            range_bytes_start:
20783
20784        Returns:
20785            The API result object.
20786        """
20787        parameters: Dict[str, str] = {
20788            'assignment_alias': assignment_alias,
20789            'course_alias': course_alias,
20790            'feedback': feedback,
20791            'guid': guid,
20792        }
20793        if range_bytes_end is not None:
20794            parameters['range_bytes_end'] = str(range_bytes_end)
20795        if range_bytes_start is not None:
20796            parameters['range_bytes_start'] = str(range_bytes_start)
20797        self._client.query('/api/submission/setFeedback/',
20798                           payload=parameters,
20799                           files_=files_,
20800                           timeout_=timeout_,
20801                           check_=check_)
20802
20803
20804TagListResponse = Sequence['_OmegaUp_Controllers_Tag__apiList_entry']
20805"""The return type of the TagList API."""
20806
20807TagFrequentTagsResponse = _OmegaUp_Controllers_Tag__apiFrequentTags
20808"""The return type of the TagFrequentTags API."""
20809
20810
20811class Tag:
20812    r"""TagController
20813    """
20814    def __init__(self, client: 'Client') -> None:
20815        self._client = client
20816
20817    def list(
20818            self,
20819            *,
20820            query: Optional[Any] = None,
20821            term: Optional[Any] = None,
20822            # Out-of-band parameters:
20823            files_: Optional[Mapping[str, BinaryIO]] = None,
20824            check_: bool = True,
20825            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
20826    ) -> TagListResponse:
20827        r"""Gets a list of tags
20828
20829        Args:
20830            query:
20831            term:
20832
20833        Returns:
20834            The API result object.
20835        """
20836        parameters: Dict[str, str] = {}
20837        if query is not None:
20838            parameters['query'] = str(query)
20839        if term is not None:
20840            parameters['term'] = str(term)
20841        return [
20842            _OmegaUp_Controllers_Tag__apiList_entry(**v)
20843            for v in self._client.query('/api/tag/list/',
20844                                        payload=parameters,
20845                                        files_=files_,
20846                                        timeout_=timeout_,
20847                                        check_=check_)
20848        ]
20849
20850    def frequentTags(
20851        self,
20852        *,
20853        problemLevel: str,
20854        rows: int,
20855        # Out-of-band parameters:
20856        files_: Optional[Mapping[str, BinaryIO]] = None,
20857        check_: bool = True,
20858        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
20859    ) -> TagFrequentTagsResponse:
20860        r"""Return most frequent public tags of a certain level
20861
20862        Args:
20863            problemLevel:
20864            rows:
20865
20866        Returns:
20867            The API result object.
20868        """
20869        parameters: Dict[str, str] = {
20870            'problemLevel': problemLevel,
20871            'rows': str(rows),
20872        }
20873        return _OmegaUp_Controllers_Tag__apiFrequentTags(
20874            **self._client.query('/api/tag/frequentTags/',
20875                                 payload=parameters,
20876                                 files_=files_,
20877                                 timeout_=timeout_,
20878                                 check_=check_))
20879
20880
20881TeamsGroupDetailsResponse = _OmegaUp_Controllers_TeamsGroup__apiDetails
20882"""The return type of the TeamsGroupDetails API."""
20883
20884TeamsGroupTeamsResponse = _OmegaUp_Controllers_TeamsGroup__apiTeams
20885"""The return type of the TeamsGroupTeams API."""
20886
20887TeamsGroupListResponse = Sequence['_ListItem']
20888"""The return type of the TeamsGroupList API."""
20889
20890TeamsGroupTeamsMembersResponse = _OmegaUp_Controllers_TeamsGroup__apiTeamsMembers
20891"""The return type of the TeamsGroupTeamsMembers API."""
20892
20893
20894class TeamsGroup:
20895    r"""TeamsGroupController
20896    """
20897    def __init__(self, client: 'Client') -> None:
20898        self._client = client
20899
20900    def details(
20901        self,
20902        *,
20903        team_group_alias: str,
20904        # Out-of-band parameters:
20905        files_: Optional[Mapping[str, BinaryIO]] = None,
20906        check_: bool = True,
20907        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
20908    ) -> TeamsGroupDetailsResponse:
20909        r"""Details of a team group
20910
20911        Args:
20912            team_group_alias:
20913
20914        Returns:
20915            The API result object.
20916        """
20917        parameters: Dict[str, str] = {
20918            'team_group_alias': team_group_alias,
20919        }
20920        return _OmegaUp_Controllers_TeamsGroup__apiDetails(
20921            **self._client.query('/api/teamsGroup/details/',
20922                                 payload=parameters,
20923                                 files_=files_,
20924                                 timeout_=timeout_,
20925                                 check_=check_))
20926
20927    def create(
20928            self,
20929            *,
20930            alias: str,
20931            description: str,
20932            name: str,
20933            numberOfContestants: Optional[int] = None,
20934            # Out-of-band parameters:
20935            files_: Optional[Mapping[str, BinaryIO]] = None,
20936            check_: bool = True,
20937            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
20938        r"""New team group
20939
20940        Args:
20941            alias:
20942            description:
20943            name:
20944            numberOfContestants:
20945
20946        Returns:
20947            The API result object.
20948        """
20949        parameters: Dict[str, str] = {
20950            'alias': alias,
20951            'description': description,
20952            'name': name,
20953        }
20954        if numberOfContestants is not None:
20955            parameters['numberOfContestants'] = str(numberOfContestants)
20956        self._client.query('/api/teamsGroup/create/',
20957                           payload=parameters,
20958                           files_=files_,
20959                           timeout_=timeout_,
20960                           check_=check_)
20961
20962    def update(
20963            self,
20964            *,
20965            alias: str,
20966            description: str,
20967            name: str,
20968            numberOfContestants: Optional[int] = None,
20969            # Out-of-band parameters:
20970            files_: Optional[Mapping[str, BinaryIO]] = None,
20971            check_: bool = True,
20972            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
20973        r"""Update an existing teams group
20974
20975        Args:
20976            alias:
20977            description:
20978            name:
20979            numberOfContestants:
20980
20981        Returns:
20982            The API result object.
20983        """
20984        parameters: Dict[str, str] = {
20985            'alias': alias,
20986            'description': description,
20987            'name': name,
20988        }
20989        if numberOfContestants is not None:
20990            parameters['numberOfContestants'] = str(numberOfContestants)
20991        self._client.query('/api/teamsGroup/update/',
20992                           payload=parameters,
20993                           files_=files_,
20994                           timeout_=timeout_,
20995                           check_=check_)
20996
20997    def teams(
20998        self,
20999        *,
21000        team_group_alias: str,
21001        # Out-of-band parameters:
21002        files_: Optional[Mapping[str, BinaryIO]] = None,
21003        check_: bool = True,
21004        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
21005    ) -> TeamsGroupTeamsResponse:
21006        r"""Teams of a teams group
21007
21008        Args:
21009            team_group_alias:
21010
21011        Returns:
21012            The API result object.
21013        """
21014        parameters: Dict[str, str] = {
21015            'team_group_alias': team_group_alias,
21016        }
21017        return _OmegaUp_Controllers_TeamsGroup__apiTeams(
21018            **self._client.query('/api/teamsGroup/teams/',
21019                                 payload=parameters,
21020                                 files_=files_,
21021                                 timeout_=timeout_,
21022                                 check_=check_))
21023
21024    def removeTeam(
21025            self,
21026            *,
21027            team_group_alias: str,
21028            usernameOrEmail: str,
21029            # Out-of-band parameters:
21030            files_: Optional[Mapping[str, BinaryIO]] = None,
21031            check_: bool = True,
21032            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
21033        r"""Remove team from teams group
21034
21035        Args:
21036            team_group_alias:
21037            usernameOrEmail:
21038
21039        Returns:
21040            The API result object.
21041        """
21042        parameters: Dict[str, str] = {
21043            'team_group_alias': team_group_alias,
21044            'usernameOrEmail': usernameOrEmail,
21045        }
21046        self._client.query('/api/teamsGroup/removeTeam/',
21047                           payload=parameters,
21048                           files_=files_,
21049                           timeout_=timeout_,
21050                           check_=check_)
21051
21052    def addMembers(
21053            self,
21054            *,
21055            team_group_alias: str,
21056            usernames: str,
21057            # Out-of-band parameters:
21058            files_: Optional[Mapping[str, BinaryIO]] = None,
21059            check_: bool = True,
21060            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
21061        r"""Add one or more users to a given team
21062
21063        Args:
21064            team_group_alias: The username of the team.
21065            usernames: Username of all members to add
21066
21067        Returns:
21068            The API result object.
21069        """
21070        parameters: Dict[str, str] = {
21071            'team_group_alias': team_group_alias,
21072            'usernames': usernames,
21073        }
21074        self._client.query('/api/teamsGroup/addMembers/',
21075                           payload=parameters,
21076                           files_=files_,
21077                           timeout_=timeout_,
21078                           check_=check_)
21079
21080    def list(
21081        self,
21082        *,
21083        query: Optional[str] = None,
21084        # Out-of-band parameters:
21085        files_: Optional[Mapping[str, BinaryIO]] = None,
21086        check_: bool = True,
21087        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
21088    ) -> TeamsGroupListResponse:
21089        r"""Gets a list of teams groups. This returns an array instead of an object
21090        since it is used by typeahead.
21091
21092        Args:
21093            query:
21094
21095        Returns:
21096            The API result object.
21097        """
21098        parameters: Dict[str, str] = {}
21099        if query is not None:
21100            parameters['query'] = query
21101        return [
21102            _ListItem(**v) for v in self._client.query('/api/teamsGroup/list/',
21103                                                       payload=parameters,
21104                                                       files_=files_,
21105                                                       timeout_=timeout_,
21106                                                       check_=check_)
21107        ]
21108
21109    def removeMember(
21110            self,
21111            *,
21112            team_group_alias: str,
21113            username: str,
21114            # Out-of-band parameters:
21115            files_: Optional[Mapping[str, BinaryIO]] = None,
21116            check_: bool = True,
21117            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
21118        r"""Remove an existing team member of a teams group
21119
21120        Args:
21121            team_group_alias: The username of the team
21122            username: The username of user to remove
21123
21124        Returns:
21125            The API result object.
21126        """
21127        parameters: Dict[str, str] = {
21128            'team_group_alias': team_group_alias,
21129            'username': username,
21130        }
21131        self._client.query('/api/teamsGroup/removeMember/',
21132                           payload=parameters,
21133                           files_=files_,
21134                           timeout_=timeout_,
21135                           check_=check_)
21136
21137    def teamsMembers(
21138        self,
21139        *,
21140        page: int,
21141        page_size: int,
21142        team_group_alias: str,
21143        # Out-of-band parameters:
21144        files_: Optional[Mapping[str, BinaryIO]] = None,
21145        check_: bool = True,
21146        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
21147    ) -> TeamsGroupTeamsMembersResponse:
21148        r"""Get a list of team members of a teams group
21149
21150        Args:
21151            page:
21152            page_size:
21153            team_group_alias: The username of the team.
21154
21155        Returns:
21156            The API result object.
21157        """
21158        parameters: Dict[str, str] = {
21159            'page': str(page),
21160            'page_size': str(page_size),
21161            'team_group_alias': team_group_alias,
21162        }
21163        return _OmegaUp_Controllers_TeamsGroup__apiTeamsMembers(
21164            **self._client.query('/api/teamsGroup/teamsMembers/',
21165                                 payload=parameters,
21166                                 files_=files_,
21167                                 timeout_=timeout_,
21168                                 check_=check_))
21169
21170
21171TimeGetResponse = _OmegaUp_Controllers_Time__apiGet
21172"""The return type of the TimeGet API."""
21173
21174
21175class Time:
21176    r"""TimeController
21177
21178    Used by arena to sync time between client and server from time to time
21179    """
21180    def __init__(self, client: 'Client') -> None:
21181        self._client = client
21182
21183    def get(
21184            self,
21185            *,
21186            # Out-of-band parameters:
21187            files_: Optional[Mapping[str, BinaryIO]] = None,
21188            check_: bool = True,
21189            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
21190    ) -> TimeGetResponse:
21191        r"""Entry point for /time API
21192
21193        Returns:
21194            The API result object.
21195        """
21196        parameters: Dict[str, str] = {}
21197        return _OmegaUp_Controllers_Time__apiGet(
21198            **self._client.query('/api/time/get/',
21199                                 payload=parameters,
21200                                 files_=files_,
21201                                 timeout_=timeout_,
21202                                 check_=check_))
21203
21204
21205UserCreateResponse = _OmegaUp_Controllers_User__apiCreate
21206"""The return type of the UserCreate API."""
21207
21208UserLoginResponse = _OmegaUp_Controllers_User__apiLogin
21209"""The return type of the UserLogin API."""
21210
21211UserMailingListBackfillResponse = _OmegaUp_Controllers_User__apiMailingListBackfill
21212"""The return type of the UserMailingListBackfill API."""
21213
21214UserGenerateOmiUsersResponse = Dict[str, str]
21215"""The return type of the UserGenerateOmiUsers API."""
21216
21217UserProfileResponse = _UserProfileInfo
21218"""The return type of the UserProfile API."""
21219
21220UserStatusVerifiedResponse = _OmegaUp_Controllers_User__apiStatusVerified
21221"""The return type of the UserStatusVerified API."""
21222
21223UserExtraInformationResponse = _OmegaUp_Controllers_User__apiExtraInformation
21224"""The return type of the UserExtraInformation API."""
21225
21226UserCoderOfTheMonthResponse = _OmegaUp_Controllers_User__apiCoderOfTheMonth
21227"""The return type of the UserCoderOfTheMonth API."""
21228
21229UserCoderOfTheMonthListResponse = _OmegaUp_Controllers_User__apiCoderOfTheMonthList
21230"""The return type of the UserCoderOfTheMonthList API."""
21231
21232UserContestStatsResponse = _OmegaUp_Controllers_User__apiContestStats
21233"""The return type of the UserContestStats API."""
21234
21235UserProblemsSolvedResponse = _OmegaUp_Controllers_User__apiProblemsSolved
21236"""The return type of the UserProblemsSolved API."""
21237
21238UserListUnsolvedProblemsResponse = _OmegaUp_Controllers_User__apiListUnsolvedProblems
21239"""The return type of the UserListUnsolvedProblems API."""
21240
21241UserProblemsCreatedResponse = _OmegaUp_Controllers_User__apiProblemsCreated
21242"""The return type of the UserProblemsCreated API."""
21243
21244UserListResponse = _OmegaUp_Controllers_User__apiList
21245"""The return type of the UserList API."""
21246
21247UserStatsResponse = _OmegaUp_Controllers_User__apiStats
21248"""The return type of the UserStats API."""
21249
21250UserValidateFilterResponse = _OmegaUp_Controllers_User__apiValidateFilter
21251"""The return type of the UserValidateFilter API."""
21252
21253UserDeleteRequestResponse = _OmegaUp_Controllers_User__apiDeleteRequest
21254"""The return type of the UserDeleteRequest API."""
21255
21256UserLastPrivacyPolicyAcceptedResponse = _OmegaUp_Controllers_User__apiLastPrivacyPolicyAccepted
21257"""The return type of the UserLastPrivacyPolicyAccepted API."""
21258
21259UserListAssociatedIdentitiesResponse = _OmegaUp_Controllers_User__apiListAssociatedIdentities
21260"""The return type of the UserListAssociatedIdentities API."""
21261
21262UserGenerateGitTokenResponse = _OmegaUp_Controllers_User__apiGenerateGitToken
21263"""The return type of the UserGenerateGitToken API."""
21264
21265UserCreateAPITokenResponse = _OmegaUp_Controllers_User__apiCreateAPIToken
21266"""The return type of the UserCreateAPIToken API."""
21267
21268UserListAPITokensResponse = _OmegaUp_Controllers_User__apiListAPITokens
21269"""The return type of the UserListAPITokens API."""
21270
21271
21272class User:
21273    r"""UserController
21274    """
21275    def __init__(self, client: 'Client') -> None:
21276        self._client = client
21277
21278    def create(
21279            self,
21280            *,
21281            # Out-of-band parameters:
21282            files_: Optional[Mapping[str, BinaryIO]] = None,
21283            check_: bool = True,
21284            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
21285    ) -> UserCreateResponse:
21286        r"""Entry point for Create a User API
21287
21288        Returns:
21289            The API result object.
21290        """
21291        parameters: Dict[str, str] = {}
21292        return _OmegaUp_Controllers_User__apiCreate(
21293            **self._client.query('/api/user/create/',
21294                                 payload=parameters,
21295                                 files_=files_,
21296                                 timeout_=timeout_,
21297                                 check_=check_))
21298
21299    def login(
21300            self,
21301            *,
21302            password: str,
21303            usernameOrEmail: str,
21304            # Out-of-band parameters:
21305            files_: Optional[Mapping[str, BinaryIO]] = None,
21306            check_: bool = True,
21307            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
21308    ) -> UserLoginResponse:
21309        r"""Exposes API /user/login
21310        Expects in request:
21311        user
21312        password
21313
21314        Args:
21315            password:
21316            usernameOrEmail:
21317
21318        Returns:
21319            The API result object.
21320        """
21321        parameters: Dict[str, str] = {
21322            'password': password,
21323            'usernameOrEmail': usernameOrEmail,
21324        }
21325        return _OmegaUp_Controllers_User__apiLogin(
21326            **self._client.query('/api/user/login/',
21327                                 payload=parameters,
21328                                 files_=files_,
21329                                 timeout_=timeout_,
21330                                 check_=check_))
21331
21332    def changePassword(
21333            self,
21334            *,
21335            old_password: str,
21336            username: str,
21337            password: Optional[str] = None,
21338            permission_key: Optional[Any] = None,
21339            # Out-of-band parameters:
21340            files_: Optional[Mapping[str, BinaryIO]] = None,
21341            check_: bool = True,
21342            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
21343        r"""Changes the password of a user
21344
21345        Args:
21346            old_password:
21347            username:
21348            password:
21349            permission_key:
21350
21351        Returns:
21352            The API result object.
21353        """
21354        parameters: Dict[str, str] = {
21355            'old_password': old_password,
21356            'username': username,
21357        }
21358        if password is not None:
21359            parameters['password'] = password
21360        if permission_key is not None:
21361            parameters['permission_key'] = str(permission_key)
21362        self._client.query('/api/user/changePassword/',
21363                           payload=parameters,
21364                           files_=files_,
21365                           timeout_=timeout_,
21366                           check_=check_)
21367
21368    def verifyEmail(
21369            self,
21370            *,
21371            id: str,
21372            usernameOrEmail: Optional[str] = None,
21373            # Out-of-band parameters:
21374            files_: Optional[Mapping[str, BinaryIO]] = None,
21375            check_: bool = True,
21376            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
21377        r"""Verifies the user given its verification id
21378
21379        Args:
21380            id:
21381            usernameOrEmail:
21382
21383        Returns:
21384            The API result object.
21385        """
21386        parameters: Dict[str, str] = {
21387            'id': id,
21388        }
21389        if usernameOrEmail is not None:
21390            parameters['usernameOrEmail'] = usernameOrEmail
21391        self._client.query('/api/user/verifyEmail/',
21392                           payload=parameters,
21393                           files_=files_,
21394                           timeout_=timeout_,
21395                           check_=check_)
21396
21397    def mailingListBackfill(
21398        self,
21399        *,
21400        # Out-of-band parameters:
21401        files_: Optional[Mapping[str, BinaryIO]] = None,
21402        check_: bool = True,
21403        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
21404    ) -> UserMailingListBackfillResponse:
21405        r"""Registers to the mailing list all users that have not been added before. Admin only
21406
21407        Returns:
21408            The API result object.
21409        """
21410        parameters: Dict[str, str] = {}
21411        return _OmegaUp_Controllers_User__apiMailingListBackfill(
21412            **self._client.query('/api/user/mailingListBackfill/',
21413                                 payload=parameters,
21414                                 files_=files_,
21415                                 timeout_=timeout_,
21416                                 check_=check_))
21417
21418    def generateOmiUsers(
21419        self,
21420        *,
21421        auth_token: str,
21422        contest_alias: str,
21423        contest_type: str,
21424        id: str,
21425        old_password: str,
21426        permission_key: str,
21427        username: str,
21428        change_password: Optional[Any] = None,
21429        password: Optional[str] = None,
21430        usernameOrEmail: Optional[str] = None,
21431        # Out-of-band parameters:
21432        files_: Optional[Mapping[str, BinaryIO]] = None,
21433        check_: bool = True,
21434        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
21435    ) -> UserGenerateOmiUsersResponse:
21436        r"""
21437
21438        Args:
21439            auth_token:
21440            contest_alias:
21441            contest_type:
21442            id:
21443            old_password:
21444            permission_key:
21445            username:
21446            change_password:
21447            password:
21448            usernameOrEmail:
21449
21450        Returns:
21451            The API result object.
21452        """
21453        parameters: Dict[str, str] = {
21454            'auth_token': auth_token,
21455            'contest_alias': contest_alias,
21456            'contest_type': contest_type,
21457            'id': id,
21458            'old_password': old_password,
21459            'permission_key': permission_key,
21460            'username': username,
21461        }
21462        if change_password is not None:
21463            parameters['change_password'] = str(change_password)
21464        if password is not None:
21465            parameters['password'] = password
21466        if usernameOrEmail is not None:
21467            parameters['usernameOrEmail'] = usernameOrEmail
21468        return {
21469            k: v
21470            for k, v in self._client.query('/api/user/generateOmiUsers/',
21471                                           payload=parameters,
21472                                           files_=files_,
21473                                           timeout_=timeout_,
21474                                           check_=check_).items()
21475        }
21476
21477    def profile(
21478        self,
21479        *,
21480        category: Optional[Any] = None,
21481        omit_rank: Optional[bool] = None,
21482        username: Optional[str] = None,
21483        # Out-of-band parameters:
21484        files_: Optional[Mapping[str, BinaryIO]] = None,
21485        check_: bool = True,
21486        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
21487    ) -> UserProfileResponse:
21488        r"""Get general user info
21489
21490        Args:
21491            category:
21492            omit_rank:
21493            username:
21494
21495        Returns:
21496            The API result object.
21497        """
21498        parameters: Dict[str, str] = {}
21499        if category is not None:
21500            parameters['category'] = str(category)
21501        if omit_rank is not None:
21502            parameters['omit_rank'] = str(omit_rank)
21503        if username is not None:
21504            parameters['username'] = username
21505        return _UserProfileInfo(**self._client.query('/api/user/profile/',
21506                                                     payload=parameters,
21507                                                     files_=files_,
21508                                                     timeout_=timeout_,
21509                                                     check_=check_))
21510
21511    def statusVerified(
21512        self,
21513        *,
21514        email: str,
21515        # Out-of-band parameters:
21516        files_: Optional[Mapping[str, BinaryIO]] = None,
21517        check_: bool = True,
21518        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
21519    ) -> UserStatusVerifiedResponse:
21520        r"""Gets verify status of a user
21521
21522        Args:
21523            email:
21524
21525        Returns:
21526            The API result object.
21527        """
21528        parameters: Dict[str, str] = {
21529            'email': email,
21530        }
21531        return _OmegaUp_Controllers_User__apiStatusVerified(
21532            **self._client.query('/api/user/statusVerified/',
21533                                 payload=parameters,
21534                                 files_=files_,
21535                                 timeout_=timeout_,
21536                                 check_=check_))
21537
21538    def extraInformation(
21539        self,
21540        *,
21541        email: str,
21542        # Out-of-band parameters:
21543        files_: Optional[Mapping[str, BinaryIO]] = None,
21544        check_: bool = True,
21545        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
21546    ) -> UserExtraInformationResponse:
21547        r"""Gets extra information of the identity:
21548        - last password change request
21549        - verify status
21550        - birth date to verify the user identity
21551
21552        Args:
21553            email:
21554
21555        Returns:
21556            The API result object.
21557        """
21558        parameters: Dict[str, str] = {
21559            'email': email,
21560        }
21561        return _OmegaUp_Controllers_User__apiExtraInformation(
21562            **self._client.query('/api/user/extraInformation/',
21563                                 payload=parameters,
21564                                 files_=files_,
21565                                 timeout_=timeout_,
21566                                 check_=check_))
21567
21568    def coderOfTheMonth(
21569        self,
21570        *,
21571        category: Optional[Any] = None,
21572        date: Optional[str] = None,
21573        # Out-of-band parameters:
21574        files_: Optional[Mapping[str, BinaryIO]] = None,
21575        check_: bool = True,
21576        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
21577    ) -> UserCoderOfTheMonthResponse:
21578        r"""Get coder of the month by trying to find it in the table using the first
21579        day of the current month. If there's no coder of the month for the given
21580        date, calculate it and save it.
21581
21582        Args:
21583            category:
21584            date:
21585
21586        Returns:
21587            The API result object.
21588        """
21589        parameters: Dict[str, str] = {}
21590        if category is not None:
21591            parameters['category'] = str(category)
21592        if date is not None:
21593            parameters['date'] = date
21594        return _OmegaUp_Controllers_User__apiCoderOfTheMonth(
21595            **self._client.query('/api/user/coderOfTheMonth/',
21596                                 payload=parameters,
21597                                 files_=files_,
21598                                 timeout_=timeout_,
21599                                 check_=check_))
21600
21601    def coderOfTheMonthList(
21602        self,
21603        *,
21604        category: Optional[Any] = None,
21605        date: Optional[str] = None,
21606        # Out-of-band parameters:
21607        files_: Optional[Mapping[str, BinaryIO]] = None,
21608        check_: bool = True,
21609        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
21610    ) -> UserCoderOfTheMonthListResponse:
21611        r"""Returns the list of coders of the month
21612
21613        Args:
21614            category:
21615            date:
21616
21617        Returns:
21618            The API result object.
21619        """
21620        parameters: Dict[str, str] = {}
21621        if category is not None:
21622            parameters['category'] = str(category)
21623        if date is not None:
21624            parameters['date'] = date
21625        return _OmegaUp_Controllers_User__apiCoderOfTheMonthList(
21626            **self._client.query('/api/user/coderOfTheMonthList/',
21627                                 payload=parameters,
21628                                 files_=files_,
21629                                 timeout_=timeout_,
21630                                 check_=check_))
21631
21632    def selectCoderOfTheMonth(
21633            self,
21634            *,
21635            username: str,
21636            category: Optional[Any] = None,
21637            # Out-of-band parameters:
21638            files_: Optional[Mapping[str, BinaryIO]] = None,
21639            check_: bool = True,
21640            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
21641        r"""Selects coder of the month for next month.
21642
21643        Args:
21644            username:
21645            category:
21646
21647        Returns:
21648            The API result object.
21649        """
21650        parameters: Dict[str, str] = {
21651            'username': username,
21652        }
21653        if category is not None:
21654            parameters['category'] = str(category)
21655        self._client.query('/api/user/selectCoderOfTheMonth/',
21656                           payload=parameters,
21657                           files_=files_,
21658                           timeout_=timeout_,
21659                           check_=check_)
21660
21661    def contestStats(
21662        self,
21663        *,
21664        username: Optional[str] = None,
21665        # Out-of-band parameters:
21666        files_: Optional[Mapping[str, BinaryIO]] = None,
21667        check_: bool = True,
21668        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
21669    ) -> UserContestStatsResponse:
21670        r"""Get Contests which a certain user has participated in
21671
21672        Args:
21673            username:
21674
21675        Returns:
21676            The API result object.
21677        """
21678        parameters: Dict[str, str] = {}
21679        if username is not None:
21680            parameters['username'] = username
21681        return _OmegaUp_Controllers_User__apiContestStats(
21682            **self._client.query('/api/user/contestStats/',
21683                                 payload=parameters,
21684                                 files_=files_,
21685                                 timeout_=timeout_,
21686                                 check_=check_))
21687
21688    def problemsSolved(
21689        self,
21690        *,
21691        username: Optional[str] = None,
21692        # Out-of-band parameters:
21693        files_: Optional[Mapping[str, BinaryIO]] = None,
21694        check_: bool = True,
21695        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
21696    ) -> UserProblemsSolvedResponse:
21697        r"""Get Problems solved by user
21698
21699        Args:
21700            username:
21701
21702        Returns:
21703            The API result object.
21704        """
21705        parameters: Dict[str, str] = {}
21706        if username is not None:
21707            parameters['username'] = username
21708        return _OmegaUp_Controllers_User__apiProblemsSolved(
21709            **self._client.query('/api/user/problemsSolved/',
21710                                 payload=parameters,
21711                                 files_=files_,
21712                                 timeout_=timeout_,
21713                                 check_=check_))
21714
21715    def listUnsolvedProblems(
21716        self,
21717        *,
21718        username: Optional[str] = None,
21719        # Out-of-band parameters:
21720        files_: Optional[Mapping[str, BinaryIO]] = None,
21721        check_: bool = True,
21722        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
21723    ) -> UserListUnsolvedProblemsResponse:
21724        r"""Get Problems unsolved by user
21725
21726        Args:
21727            username:
21728
21729        Returns:
21730            The API result object.
21731        """
21732        parameters: Dict[str, str] = {}
21733        if username is not None:
21734            parameters['username'] = username
21735        return _OmegaUp_Controllers_User__apiListUnsolvedProblems(
21736            **self._client.query('/api/user/listUnsolvedProblems/',
21737                                 payload=parameters,
21738                                 files_=files_,
21739                                 timeout_=timeout_,
21740                                 check_=check_))
21741
21742    def problemsCreated(
21743        self,
21744        *,
21745        username: Optional[str] = None,
21746        # Out-of-band parameters:
21747        files_: Optional[Mapping[str, BinaryIO]] = None,
21748        check_: bool = True,
21749        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
21750    ) -> UserProblemsCreatedResponse:
21751        r"""Get Problems created by user
21752
21753        Args:
21754            username:
21755
21756        Returns:
21757            The API result object.
21758        """
21759        parameters: Dict[str, str] = {}
21760        if username is not None:
21761            parameters['username'] = username
21762        return _OmegaUp_Controllers_User__apiProblemsCreated(
21763            **self._client.query('/api/user/problemsCreated/',
21764                                 payload=parameters,
21765                                 files_=files_,
21766                                 timeout_=timeout_,
21767                                 check_=check_))
21768
21769    def list(
21770            self,
21771            *,
21772            query: Optional[str] = None,
21773            rowcount: Optional[int] = None,
21774            term: Optional[str] = None,
21775            # Out-of-band parameters:
21776            files_: Optional[Mapping[str, BinaryIO]] = None,
21777            check_: bool = True,
21778            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
21779    ) -> UserListResponse:
21780        r"""Gets a list of users.
21781
21782        Args:
21783            query:
21784            rowcount:
21785            term:
21786
21787        Returns:
21788            The API result object.
21789        """
21790        parameters: Dict[str, str] = {}
21791        if query is not None:
21792            parameters['query'] = query
21793        if rowcount is not None:
21794            parameters['rowcount'] = str(rowcount)
21795        if term is not None:
21796            parameters['term'] = term
21797        return _OmegaUp_Controllers_User__apiList(
21798            **self._client.query('/api/user/list/',
21799                                 payload=parameters,
21800                                 files_=files_,
21801                                 timeout_=timeout_,
21802                                 check_=check_))
21803
21804    def stats(
21805            self,
21806            *,
21807            username: Optional[str] = None,
21808            # Out-of-band parameters:
21809            files_: Optional[Mapping[str, BinaryIO]] = None,
21810            check_: bool = True,
21811            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
21812    ) -> UserStatsResponse:
21813        r"""Get stats
21814
21815        Args:
21816            username:
21817
21818        Returns:
21819            The API result object.
21820        """
21821        parameters: Dict[str, str] = {}
21822        if username is not None:
21823            parameters['username'] = username
21824        return _OmegaUp_Controllers_User__apiStats(
21825            **self._client.query('/api/user/stats/',
21826                                 payload=parameters,
21827                                 files_=files_,
21828                                 timeout_=timeout_,
21829                                 check_=check_))
21830
21831    def updateBasicInfo(
21832            self,
21833            *,
21834            password: str,
21835            username: str,
21836            # Out-of-band parameters:
21837            files_: Optional[Mapping[str, BinaryIO]] = None,
21838            check_: bool = True,
21839            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
21840        r"""Update basic user profile info when logged with fb/gool
21841
21842        Args:
21843            password:
21844            username:
21845
21846        Returns:
21847            The API result object.
21848        """
21849        parameters: Dict[str, str] = {
21850            'password': password,
21851            'username': username,
21852        }
21853        self._client.query('/api/user/updateBasicInfo/',
21854                           payload=parameters,
21855                           files_=files_,
21856                           timeout_=timeout_,
21857                           check_=check_)
21858
21859    def update(
21860            self,
21861            *,
21862            birth_date: str,
21863            country_id: str,
21864            graduation_date: str,
21865            locale: str,
21866            state_id: str,
21867            auth_token: Optional[Any] = None,
21868            gender: Optional[str] = None,
21869            has_competitive_objective: Optional[bool] = None,
21870            has_learning_objective: Optional[bool] = None,
21871            has_scholar_objective: Optional[bool] = None,
21872            has_teaching_objective: Optional[bool] = None,
21873            hide_problem_tags: Optional[bool] = None,
21874            is_private: Optional[bool] = None,
21875            name: Optional[str] = None,
21876            scholar_degree: Optional[str] = None,
21877            school_id: Optional[int] = None,
21878            school_name: Optional[str] = None,
21879            username: Optional[Any] = None,
21880            # Out-of-band parameters:
21881            files_: Optional[Mapping[str, BinaryIO]] = None,
21882            check_: bool = True,
21883            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
21884        r"""Update user profile
21885
21886        Args:
21887            birth_date:
21888            country_id:
21889            graduation_date:
21890            locale:
21891            state_id:
21892            auth_token:
21893            gender:
21894            has_competitive_objective:
21895            has_learning_objective:
21896            has_scholar_objective:
21897            has_teaching_objective:
21898            hide_problem_tags:
21899            is_private:
21900            name:
21901            scholar_degree:
21902            school_id:
21903            school_name:
21904            username:
21905
21906        Returns:
21907            The API result object.
21908        """
21909        parameters: Dict[str, str] = {
21910            'birth_date': birth_date,
21911            'country_id': country_id,
21912            'graduation_date': graduation_date,
21913            'locale': locale,
21914            'state_id': state_id,
21915        }
21916        if auth_token is not None:
21917            parameters['auth_token'] = str(auth_token)
21918        if gender is not None:
21919            parameters['gender'] = gender
21920        if has_competitive_objective is not None:
21921            parameters['has_competitive_objective'] = str(
21922                has_competitive_objective)
21923        if has_learning_objective is not None:
21924            parameters['has_learning_objective'] = str(has_learning_objective)
21925        if has_scholar_objective is not None:
21926            parameters['has_scholar_objective'] = str(has_scholar_objective)
21927        if has_teaching_objective is not None:
21928            parameters['has_teaching_objective'] = str(has_teaching_objective)
21929        if hide_problem_tags is not None:
21930            parameters['hide_problem_tags'] = str(hide_problem_tags)
21931        if is_private is not None:
21932            parameters['is_private'] = str(is_private)
21933        if name is not None:
21934            parameters['name'] = name
21935        if scholar_degree is not None:
21936            parameters['scholar_degree'] = scholar_degree
21937        if school_id is not None:
21938            parameters['school_id'] = str(school_id)
21939        if school_name is not None:
21940            parameters['school_name'] = school_name
21941        if username is not None:
21942            parameters['username'] = str(username)
21943        self._client.query('/api/user/update/',
21944                           payload=parameters,
21945                           files_=files_,
21946                           timeout_=timeout_,
21947                           check_=check_)
21948
21949    def updateMainEmail(
21950            self,
21951            *,
21952            email: str,
21953            originalEmail: Optional[str] = None,
21954            # Out-of-band parameters:
21955            files_: Optional[Mapping[str, BinaryIO]] = None,
21956            check_: bool = True,
21957            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
21958        r"""Updates the main email of the current user
21959
21960        Args:
21961            email:
21962            originalEmail:
21963
21964        Returns:
21965            The API result object.
21966        """
21967        parameters: Dict[str, str] = {
21968            'email': email,
21969        }
21970        if originalEmail is not None:
21971            parameters['originalEmail'] = originalEmail
21972        self._client.query('/api/user/updateMainEmail/',
21973                           payload=parameters,
21974                           files_=files_,
21975                           timeout_=timeout_,
21976                           check_=check_)
21977
21978    def validateFilter(
21979        self,
21980        *,
21981        filter: str,
21982        problemset_id: int,
21983        auth_token: Optional[str] = None,
21984        contest_admin: Optional[str] = None,
21985        contest_alias: Optional[str] = None,
21986        token: Optional[str] = None,
21987        tokens: Optional[Any] = None,
21988        # Out-of-band parameters:
21989        files_: Optional[Mapping[str, BinaryIO]] = None,
21990        check_: bool = True,
21991        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
21992    ) -> UserValidateFilterResponse:
21993        r"""Parses and validates a filter string to be used for event notification
21994        filtering.
21995
21996        The Request must have a 'filter' key with comma-delimited URI paths
21997        representing the resources the caller is interested in receiving events
21998        for. If the caller has enough privileges to receive notifications for
21999        ALL the requested filters, the request will return successfully,
22000        otherwise an exception will be thrown.
22001
22002        This API does not need authentication to be used. This allows to track
22003        contest updates with an access token.
22004
22005        Args:
22006            filter:
22007            problemset_id:
22008            auth_token:
22009            contest_admin:
22010            contest_alias:
22011            token:
22012            tokens:
22013
22014        Returns:
22015            The API result object.
22016        """
22017        parameters: Dict[str, str] = {
22018            'filter': filter,
22019            'problemset_id': str(problemset_id),
22020        }
22021        if auth_token is not None:
22022            parameters['auth_token'] = auth_token
22023        if contest_admin is not None:
22024            parameters['contest_admin'] = contest_admin
22025        if contest_alias is not None:
22026            parameters['contest_alias'] = contest_alias
22027        if token is not None:
22028            parameters['token'] = token
22029        if tokens is not None:
22030            parameters['tokens'] = str(tokens)
22031        return _OmegaUp_Controllers_User__apiValidateFilter(
22032            **self._client.query('/api/user/validateFilter/',
22033                                 payload=parameters,
22034                                 files_=files_,
22035                                 timeout_=timeout_,
22036                                 check_=check_))
22037
22038    def addRole(
22039            self,
22040            *,
22041            role: str,
22042            username: str,
22043            # Out-of-band parameters:
22044            files_: Optional[Mapping[str, BinaryIO]] = None,
22045            check_: bool = True,
22046            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
22047        r"""Adds the role to the user.
22048
22049        Args:
22050            role:
22051            username:
22052
22053        Returns:
22054            The API result object.
22055        """
22056        parameters: Dict[str, str] = {
22057            'role': role,
22058            'username': username,
22059        }
22060        self._client.query('/api/user/addRole/',
22061                           payload=parameters,
22062                           files_=files_,
22063                           timeout_=timeout_,
22064                           check_=check_)
22065
22066    def removeRole(
22067            self,
22068            *,
22069            role: str,
22070            username: str,
22071            # Out-of-band parameters:
22072            files_: Optional[Mapping[str, BinaryIO]] = None,
22073            check_: bool = True,
22074            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
22075        r"""Removes the role from the user.
22076
22077        Args:
22078            role:
22079            username:
22080
22081        Returns:
22082            The API result object.
22083        """
22084        parameters: Dict[str, str] = {
22085            'role': role,
22086            'username': username,
22087        }
22088        self._client.query('/api/user/removeRole/',
22089                           payload=parameters,
22090                           files_=files_,
22091                           timeout_=timeout_,
22092                           check_=check_)
22093
22094    def deleteRequest(
22095        self,
22096        *,
22097        username: Optional[str] = None,
22098        # Out-of-band parameters:
22099        files_: Optional[Mapping[str, BinaryIO]] = None,
22100        check_: bool = True,
22101        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
22102    ) -> UserDeleteRequestResponse:
22103        r"""
22104
22105        Args:
22106            username:
22107
22108        Returns:
22109            The API result object.
22110        """
22111        parameters: Dict[str, str] = {}
22112        if username is not None:
22113            parameters['username'] = username
22114        return _OmegaUp_Controllers_User__apiDeleteRequest(
22115            **self._client.query('/api/user/deleteRequest/',
22116                                 payload=parameters,
22117                                 files_=files_,
22118                                 timeout_=timeout_,
22119                                 check_=check_))
22120
22121    def deleteConfirm(
22122            self,
22123            *,
22124            token: str,
22125            username: Optional[str] = None,
22126            # Out-of-band parameters:
22127            files_: Optional[Mapping[str, BinaryIO]] = None,
22128            check_: bool = True,
22129            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
22130        r"""
22131
22132        Args:
22133            token:
22134            username:
22135
22136        Returns:
22137            The API result object.
22138        """
22139        parameters: Dict[str, str] = {
22140            'token': token,
22141        }
22142        if username is not None:
22143            parameters['username'] = username
22144        self._client.query('/api/user/deleteConfirm/',
22145                           payload=parameters,
22146                           files_=files_,
22147                           timeout_=timeout_,
22148                           check_=check_)
22149
22150    def addGroup(
22151            self,
22152            *,
22153            group: str,
22154            # Out-of-band parameters:
22155            files_: Optional[Mapping[str, BinaryIO]] = None,
22156            check_: bool = True,
22157            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
22158        r"""Adds the identity to the group.
22159
22160        Args:
22161            group:
22162
22163        Returns:
22164            The API result object.
22165        """
22166        parameters: Dict[str, str] = {
22167            'group': group,
22168        }
22169        self._client.query('/api/user/addGroup/',
22170                           payload=parameters,
22171                           files_=files_,
22172                           timeout_=timeout_,
22173                           check_=check_)
22174
22175    def removeGroup(
22176            self,
22177            *,
22178            group: str,
22179            # Out-of-band parameters:
22180            files_: Optional[Mapping[str, BinaryIO]] = None,
22181            check_: bool = True,
22182            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
22183        r"""Removes the user to the group.
22184
22185        Args:
22186            group:
22187
22188        Returns:
22189            The API result object.
22190        """
22191        parameters: Dict[str, str] = {
22192            'group': group,
22193        }
22194        self._client.query('/api/user/removeGroup/',
22195                           payload=parameters,
22196                           files_=files_,
22197                           timeout_=timeout_,
22198                           check_=check_)
22199
22200    def addExperiment(
22201            self,
22202            *,
22203            experiment: str,
22204            username: str,
22205            # Out-of-band parameters:
22206            files_: Optional[Mapping[str, BinaryIO]] = None,
22207            check_: bool = True,
22208            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
22209        r"""Adds the experiment to the user.
22210
22211        Args:
22212            experiment:
22213            username:
22214
22215        Returns:
22216            The API result object.
22217        """
22218        parameters: Dict[str, str] = {
22219            'experiment': experiment,
22220            'username': username,
22221        }
22222        self._client.query('/api/user/addExperiment/',
22223                           payload=parameters,
22224                           files_=files_,
22225                           timeout_=timeout_,
22226                           check_=check_)
22227
22228    def removeExperiment(
22229            self,
22230            *,
22231            experiment: str,
22232            username: str,
22233            # Out-of-band parameters:
22234            files_: Optional[Mapping[str, BinaryIO]] = None,
22235            check_: bool = True,
22236            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
22237        r"""Removes the experiment from the user.
22238
22239        Args:
22240            experiment:
22241            username:
22242
22243        Returns:
22244            The API result object.
22245        """
22246        parameters: Dict[str, str] = {
22247            'experiment': experiment,
22248            'username': username,
22249        }
22250        self._client.query('/api/user/removeExperiment/',
22251                           payload=parameters,
22252                           files_=files_,
22253                           timeout_=timeout_,
22254                           check_=check_)
22255
22256    def lastPrivacyPolicyAccepted(
22257        self,
22258        *,
22259        username: Optional[str] = None,
22260        # Out-of-band parameters:
22261        files_: Optional[Mapping[str, BinaryIO]] = None,
22262        check_: bool = True,
22263        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
22264    ) -> UserLastPrivacyPolicyAcceptedResponse:
22265        r"""Gets the last privacy policy accepted by user
22266
22267        Args:
22268            username:
22269
22270        Returns:
22271            The API result object.
22272        """
22273        parameters: Dict[str, str] = {}
22274        if username is not None:
22275            parameters['username'] = username
22276        return _OmegaUp_Controllers_User__apiLastPrivacyPolicyAccepted(
22277            **self._client.query('/api/user/lastPrivacyPolicyAccepted/',
22278                                 payload=parameters,
22279                                 files_=files_,
22280                                 timeout_=timeout_,
22281                                 check_=check_))
22282
22283    def acceptPrivacyPolicy(
22284            self,
22285            *,
22286            privacy_git_object_id: str,
22287            statement_type: str,
22288            username: Optional[str] = None,
22289            # Out-of-band parameters:
22290            files_: Optional[Mapping[str, BinaryIO]] = None,
22291            check_: bool = True,
22292            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
22293        r"""Keeps a record of a user who accepts the privacy policy
22294
22295        Args:
22296            privacy_git_object_id:
22297            statement_type:
22298            username:
22299
22300        Returns:
22301            The API result object.
22302        """
22303        parameters: Dict[str, str] = {
22304            'privacy_git_object_id': privacy_git_object_id,
22305            'statement_type': statement_type,
22306        }
22307        if username is not None:
22308            parameters['username'] = username
22309        self._client.query('/api/user/acceptPrivacyPolicy/',
22310                           payload=parameters,
22311                           files_=files_,
22312                           timeout_=timeout_,
22313                           check_=check_)
22314
22315    def associateIdentity(
22316            self,
22317            *,
22318            password: str,
22319            username: str,
22320            # Out-of-band parameters:
22321            files_: Optional[Mapping[str, BinaryIO]] = None,
22322            check_: bool = True,
22323            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
22324        r"""Associates an identity to the logged user given the username
22325
22326        Args:
22327            password:
22328            username:
22329
22330        Returns:
22331            The API result object.
22332        """
22333        parameters: Dict[str, str] = {
22334            'password': password,
22335            'username': username,
22336        }
22337        self._client.query('/api/user/associateIdentity/',
22338                           payload=parameters,
22339                           files_=files_,
22340                           timeout_=timeout_,
22341                           check_=check_)
22342
22343    def listAssociatedIdentities(
22344        self,
22345        *,
22346        # Out-of-band parameters:
22347        files_: Optional[Mapping[str, BinaryIO]] = None,
22348        check_: bool = True,
22349        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
22350    ) -> UserListAssociatedIdentitiesResponse:
22351        r"""Get the identities that have been associated to the logged user
22352
22353        Returns:
22354            The API result object.
22355        """
22356        parameters: Dict[str, str] = {}
22357        return _OmegaUp_Controllers_User__apiListAssociatedIdentities(
22358            **self._client.query('/api/user/listAssociatedIdentities/',
22359                                 payload=parameters,
22360                                 files_=files_,
22361                                 timeout_=timeout_,
22362                                 check_=check_))
22363
22364    def generateGitToken(
22365        self,
22366        *,
22367        # Out-of-band parameters:
22368        files_: Optional[Mapping[str, BinaryIO]] = None,
22369        check_: bool = True,
22370        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
22371    ) -> UserGenerateGitTokenResponse:
22372        r"""Generate a new gitserver token. This token can be used to authenticate
22373        against the gitserver.
22374
22375        Returns:
22376            The API result object.
22377        """
22378        parameters: Dict[str, str] = {}
22379        return _OmegaUp_Controllers_User__apiGenerateGitToken(
22380            **self._client.query('/api/user/generateGitToken/',
22381                                 payload=parameters,
22382                                 files_=files_,
22383                                 timeout_=timeout_,
22384                                 check_=check_))
22385
22386    def createAPIToken(
22387        self,
22388        *,
22389        name: str,
22390        # Out-of-band parameters:
22391        files_: Optional[Mapping[str, BinaryIO]] = None,
22392        check_: bool = True,
22393        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
22394    ) -> UserCreateAPITokenResponse:
22395        r"""Creates a new API token associated with the user.
22396
22397        This token can be used to authenticate against the API in other calls
22398        through the [HTTP `Authorization`
22399        header](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Authorization)
22400        in the request:
22401
22402        ```
22403        Authorization: token 92d8c5a0eceef3c05f4149fc04b62bb2cd50d9c6
22404        ```
22405
22406        The following alternative syntax allows to specify an associated
22407        identity:
22408
22409        ```
22410        Authorization: token Credential=92d8c5a0eceef3c05f4149fc04b62bb2cd50d9c6,Username=groupname:username
22411        ```
22412
22413        There is a limit of 1000 requests that can be done every hour, after
22414        which point all requests will fail with [HTTP 429 Too Many
22415        Requests](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/429).
22416        The `X-RateLimit-Limit`, `X-RateLimit-Remaining`, and
22417        `X-RateLimit-Reset` response headers will be set whenever an API token
22418        is used and will contain useful information about the limit to the
22419        caller.
22420
22421        There is a limit of 5 API tokens that each user can have.
22422
22423        Args:
22424            name: A non-empty alphanumeric string. May contain underscores and dashes.
22425
22426        Returns:
22427            The API result object.
22428        """
22429        parameters: Dict[str, str] = {
22430            'name': name,
22431        }
22432        return _OmegaUp_Controllers_User__apiCreateAPIToken(
22433            **self._client.query('/api/user/createAPIToken/',
22434                                 payload=parameters,
22435                                 files_=files_,
22436                                 timeout_=timeout_,
22437                                 check_=check_))
22438
22439    def listAPITokens(
22440        self,
22441        *,
22442        # Out-of-band parameters:
22443        files_: Optional[Mapping[str, BinaryIO]] = None,
22444        check_: bool = True,
22445        timeout_: datetime.timedelta = _DEFAULT_TIMEOUT
22446    ) -> UserListAPITokensResponse:
22447        r"""Returns a list of all the API tokens associated with the user.
22448
22449        Returns:
22450            The API result object.
22451        """
22452        parameters: Dict[str, str] = {}
22453        return _OmegaUp_Controllers_User__apiListAPITokens(
22454            **self._client.query('/api/user/listAPITokens/',
22455                                 payload=parameters,
22456                                 files_=files_,
22457                                 timeout_=timeout_,
22458                                 check_=check_))
22459
22460    def revokeAPIToken(
22461            self,
22462            *,
22463            name: str,
22464            # Out-of-band parameters:
22465            files_: Optional[Mapping[str, BinaryIO]] = None,
22466            check_: bool = True,
22467            timeout_: datetime.timedelta = _DEFAULT_TIMEOUT) -> None:
22468        r"""Revokes an API token associated with the user.
22469
22470        Args:
22471            name: A non-empty alphanumeric string. May contain underscores and dashes.
22472
22473        Returns:
22474            The API result object.
22475        """
22476        parameters: Dict[str, str] = {
22477            'name': name,
22478        }
22479        self._client.query('/api/user/revokeAPIToken/',
22480                           payload=parameters,
22481                           files_=files_,
22482                           timeout_=timeout_,
22483                           check_=check_)
22484
22485
22486class Client:
22487    """.""",
22488
22489    def __init__(self,
22490                 *,
22491                 username: Optional[str] = None,
22492                 password: Optional[str] = None,
22493                 api_token: Optional[str] = None,
22494                 auth_token: Optional[str] = None,
22495                 url: str = 'https://omegaup.com') -> None:
22496        self._url = url
22497        self.username: Optional[str] = username
22498        self.api_token: Optional[str] = api_token
22499        self.auth_token: Optional[str] = None
22500        if api_token is None:
22501            if username is None:
22502                raise ValueError(
22503                    'username cannot be None if api_token is not provided', )
22504            if auth_token is not None:
22505                self.auth_token = auth_token
22506            elif password is not None:
22507                self.auth_token = self.query('/api/user/login/',
22508                                             payload={
22509                                                 'usernameOrEmail': username,
22510                                                 'password': password,
22511                                             })['auth_token']
22512        self._admin: Optional[Admin] = None
22513        self._authorization: Optional[Authorization] = None
22514        self._badge: Optional[Badge] = None
22515        self._clarification: Optional[Clarification] = None
22516        self._contest: Optional[Contest] = None
22517        self._course: Optional[Course] = None
22518        self._grader: Optional[Grader] = None
22519        self._group: Optional[Group] = None
22520        self._groupScoreboard: Optional[GroupScoreboard] = None
22521        self._identity: Optional[Identity] = None
22522        self._notification: Optional[Notification] = None
22523        self._problem: Optional[Problem] = None
22524        self._problemForfeited: Optional[ProblemForfeited] = None
22525        self._problemset: Optional[Problemset] = None
22526        self._qualityNomination: Optional[QualityNomination] = None
22527        self._reset: Optional[Reset] = None
22528        self._run: Optional[Run] = None
22529        self._school: Optional[School] = None
22530        self._scoreboard: Optional[Scoreboard] = None
22531        self._session: Optional[Session] = None
22532        self._submission: Optional[Submission] = None
22533        self._tag: Optional[Tag] = None
22534        self._teamsGroup: Optional[TeamsGroup] = None
22535        self._time: Optional[Time] = None
22536        self._user: Optional[User] = None
22537
22538    def query(self,
22539              endpoint: str,
22540              payload: Optional[Mapping[str, str]] = None,
22541              files_: Optional[Mapping[str, BinaryIO]] = None,
22542              timeout_: datetime.timedelta = _DEFAULT_TIMEOUT,
22543              check_: bool = True) -> ApiReturnType:
22544        """Issues a raw query to the omegaUp API."""
22545        logger = logging.getLogger('omegaup')
22546        if payload is None:
22547            payload = {}
22548        else:
22549            payload = dict(payload)
22550
22551        if logger.isEnabledFor(logging.DEBUG):
22552            logger.debug('Calling endpoint: %s', endpoint)
22553            logger.debug('Payload: %s', _filterKeys(payload, {'password'}))
22554
22555        headers = {}
22556        if self.api_token is not None:
22557            if self.username is not None:
22558                headers['Authorization'] = ','.join((
22559                    f'Credential={self.api_token}',
22560                    f'Username={self.username}',
22561                ))
22562            else:
22563                headers['Authorization'] = f'token {self.api_token}'
22564        elif self.auth_token is not None:
22565            payload['ouat'] = self.auth_token
22566
22567        r = requests.post(urllib.parse.urljoin(self._url, endpoint),
22568                          data=payload,
22569                          headers=headers,
22570                          files=files_,
22571                          timeout=timeout_.total_seconds())
22572
22573        try:
22574            response: ApiReturnType = r.json()
22575        except:  # noqa: bare-except Re-raised below
22576            logger.exception(r.text)
22577            raise
22578
22579        if logger.isEnabledFor(logging.DEBUG):
22580            logger.info('Response: %s', _filterKeys(response, {'auth_token'}))
22581
22582        if check_ and r.status_code != 200:
22583            raise Exception(response)
22584
22585        return response
22586
22587    @property
22588    def admin(self) -> Admin:
22589        """Returns the Admin API."""
22590        if self._admin is None:
22591            self._admin = Admin(self)
22592        return self._admin
22593
22594    @property
22595    def authorization(self) -> Authorization:
22596        """Returns the Authorization API."""
22597        if self._authorization is None:
22598            self._authorization = Authorization(self)
22599        return self._authorization
22600
22601    @property
22602    def badge(self) -> Badge:
22603        """Returns the Badge API."""
22604        if self._badge is None:
22605            self._badge = Badge(self)
22606        return self._badge
22607
22608    @property
22609    def clarification(self) -> Clarification:
22610        """Returns the Clarification API."""
22611        if self._clarification is None:
22612            self._clarification = Clarification(self)
22613        return self._clarification
22614
22615    @property
22616    def contest(self) -> Contest:
22617        """Returns the Contest API."""
22618        if self._contest is None:
22619            self._contest = Contest(self)
22620        return self._contest
22621
22622    @property
22623    def course(self) -> Course:
22624        """Returns the Course API."""
22625        if self._course is None:
22626            self._course = Course(self)
22627        return self._course
22628
22629    @property
22630    def grader(self) -> Grader:
22631        """Returns the Grader API."""
22632        if self._grader is None:
22633            self._grader = Grader(self)
22634        return self._grader
22635
22636    @property
22637    def group(self) -> Group:
22638        """Returns the Group API."""
22639        if self._group is None:
22640            self._group = Group(self)
22641        return self._group
22642
22643    @property
22644    def groupScoreboard(self) -> GroupScoreboard:
22645        """Returns the GroupScoreboard API."""
22646        if self._groupScoreboard is None:
22647            self._groupScoreboard = GroupScoreboard(self)
22648        return self._groupScoreboard
22649
22650    @property
22651    def identity(self) -> Identity:
22652        """Returns the Identity API."""
22653        if self._identity is None:
22654            self._identity = Identity(self)
22655        return self._identity
22656
22657    @property
22658    def notification(self) -> Notification:
22659        """Returns the Notification API."""
22660        if self._notification is None:
22661            self._notification = Notification(self)
22662        return self._notification
22663
22664    @property
22665    def problem(self) -> Problem:
22666        """Returns the Problem API."""
22667        if self._problem is None:
22668            self._problem = Problem(self)
22669        return self._problem
22670
22671    @property
22672    def problemForfeited(self) -> ProblemForfeited:
22673        """Returns the ProblemForfeited API."""
22674        if self._problemForfeited is None:
22675            self._problemForfeited = ProblemForfeited(self)
22676        return self._problemForfeited
22677
22678    @property
22679    def problemset(self) -> Problemset:
22680        """Returns the Problemset API."""
22681        if self._problemset is None:
22682            self._problemset = Problemset(self)
22683        return self._problemset
22684
22685    @property
22686    def qualityNomination(self) -> QualityNomination:
22687        """Returns the QualityNomination API."""
22688        if self._qualityNomination is None:
22689            self._qualityNomination = QualityNomination(self)
22690        return self._qualityNomination
22691
22692    @property
22693    def reset(self) -> Reset:
22694        """Returns the Reset API."""
22695        if self._reset is None:
22696            self._reset = Reset(self)
22697        return self._reset
22698
22699    @property
22700    def run(self) -> Run:
22701        """Returns the Run API."""
22702        if self._run is None:
22703            self._run = Run(self)
22704        return self._run
22705
22706    @property
22707    def school(self) -> School:
22708        """Returns the School API."""
22709        if self._school is None:
22710            self._school = School(self)
22711        return self._school
22712
22713    @property
22714    def scoreboard(self) -> Scoreboard:
22715        """Returns the Scoreboard API."""
22716        if self._scoreboard is None:
22717            self._scoreboard = Scoreboard(self)
22718        return self._scoreboard
22719
22720    @property
22721    def session(self) -> Session:
22722        """Returns the Session API."""
22723        if self._session is None:
22724            self._session = Session(self)
22725        return self._session
22726
22727    @property
22728    def submission(self) -> Submission:
22729        """Returns the Submission API."""
22730        if self._submission is None:
22731            self._submission = Submission(self)
22732        return self._submission
22733
22734    @property
22735    def tag(self) -> Tag:
22736        """Returns the Tag API."""
22737        if self._tag is None:
22738            self._tag = Tag(self)
22739        return self._tag
22740
22741    @property
22742    def teamsGroup(self) -> TeamsGroup:
22743        """Returns the TeamsGroup API."""
22744        if self._teamsGroup is None:
22745            self._teamsGroup = TeamsGroup(self)
22746        return self._teamsGroup
22747
22748    @property
22749    def time(self) -> Time:
22750        """Returns the Time API."""
22751        if self._time is None:
22752            self._time = Time(self)
22753        return self._time
22754
22755    @property
22756    def user(self) -> User:
22757        """Returns the User API."""
22758        if self._user is None:
22759            self._user = User(self)
22760        return self._user