From ebd1c4739ba08b4cac14705e08f41ea77bd64b5f Mon Sep 17 00:00:00 2001 From: Bovard Doerschuk-Tiberi Date: Mon, 29 Jun 2026 16:33:58 +0000 Subject: [PATCH] Regenerate SDK: competition API surface Adds new competitions protos and refreshes competition_api_service: - host_service: includes CompetitionSimulationSettings (#43562) - episode_service: includes GetEpisodeSummary admin RPC (#43523) - competition_api_service: adds CreateCompetition (#43550), CreateCompetitionPage (#43543), and LaunchCompetition (#43579), plus the Reward type and CompetitionPrivacy enum they depend on. Note: UpdateCompetitionPage (PATCH), DeleteCompetitionPage (DELETE), and UpdateCompetitionSettings (PATCH) still do not appear in the python client. kapigen's public-API reachability filter only marks methods reached via HTTP GET or POST; PATCH and DELETE bindings are not detected. --- .../services/competition_api_service.py | 38 +- .../competitions/services/episode_service.py | 169 ++ .../competitions/services/host_service.py | 398 +++ kagglesdk/competitions/types/competition.py | 65 + .../types/competition_api_service.py | 557 +++- .../competitions/types/competition_enums.py | 7 + .../competitions/types/episode_service.py | 1475 ++++++++++ kagglesdk/competitions/types/host_service.py | 2485 +++++++++++++++++ 8 files changed, 5192 insertions(+), 2 deletions(-) create mode 100644 kagglesdk/competitions/services/episode_service.py create mode 100644 kagglesdk/competitions/services/host_service.py create mode 100644 kagglesdk/competitions/types/episode_service.py create mode 100644 kagglesdk/competitions/types/host_service.py diff --git a/kagglesdk/competitions/services/competition_api_service.py b/kagglesdk/competitions/services/competition_api_service.py index 896cf56..40fa125 100644 --- a/kagglesdk/competitions/services/competition_api_service.py +++ b/kagglesdk/competitions/services/competition_api_service.py @@ -1,6 +1,6 @@ from kagglesdk.common.types.file_download import FileDownload from kagglesdk.common.types.http_redirect import HttpRedirect -from kagglesdk.competitions.types.competition_api_service import ApiCompetition, ApiCreateCodeSubmissionRequest, ApiCreateCodeSubmissionResponse, ApiCreateSubmissionRequest, ApiCreateSubmissionResponse, ApiDownloadDataFileRequest, ApiDownloadDataFilesRequest, ApiDownloadLeaderboardRequest, ApiGetCompetitionDataFilesSummaryRequest, ApiGetCompetitionRequest, ApiGetEpisodeAgentLogsRequest, ApiGetEpisodeReplayRequest, ApiGetLeaderboardRequest, ApiGetLeaderboardResponse, ApiGetSubmissionRequest, ApiListCompetitionPagesRequest, ApiListCompetitionPagesResponse, ApiListCompetitionsRequest, ApiListCompetitionsResponse, ApiListCompetitionTopicsRequest, ApiListCompetitionTopicsResponse, ApiListDataFilesRequest, ApiListDataFilesResponse, ApiListDataTreeFilesRequest, ApiListSubmissionEpisodesRequest, ApiListSubmissionEpisodesResponse, ApiListSubmissionsRequest, ApiListSubmissionsResponse, ApiListTeamPublicSubmissionsRequest, ApiListTeamPublicSubmissionsResponse, ApiListTopicMessagesRequest, ApiListTopicMessagesResponse, ApiStartSubmissionUploadRequest, ApiStartSubmissionUploadResponse, ApiSubmission +from kagglesdk.competitions.types.competition_api_service import ApiCompetition, ApiCompetitionPage, ApiCreateCodeSubmissionRequest, ApiCreateCodeSubmissionResponse, ApiCreateCompetitionPageRequest, ApiCreateCompetitionRequest, ApiCreateCompetitionResponse, ApiCreateSubmissionRequest, ApiCreateSubmissionResponse, ApiDownloadDataFileRequest, ApiDownloadDataFilesRequest, ApiDownloadLeaderboardRequest, ApiGetCompetitionDataFilesSummaryRequest, ApiGetCompetitionRequest, ApiGetEpisodeAgentLogsRequest, ApiGetEpisodeReplayRequest, ApiGetLeaderboardRequest, ApiGetLeaderboardResponse, ApiGetSubmissionRequest, ApiLaunchCompetitionRequest, ApiListCompetitionPagesRequest, ApiListCompetitionPagesResponse, ApiListCompetitionsRequest, ApiListCompetitionsResponse, ApiListCompetitionTopicsRequest, ApiListCompetitionTopicsResponse, ApiListDataFilesRequest, ApiListDataFilesResponse, ApiListDataTreeFilesRequest, ApiListSubmissionEpisodesRequest, ApiListSubmissionEpisodesResponse, ApiListSubmissionsRequest, ApiListSubmissionsResponse, ApiListTeamPublicSubmissionsRequest, ApiListTeamPublicSubmissionsResponse, ApiListTopicMessagesRequest, ApiListTopicMessagesResponse, ApiStartSubmissionUploadRequest, ApiStartSubmissionUploadResponse, ApiSubmission from kagglesdk.datasets.databundles.types.databundle_api_types import ApiDirectoryContent, ApiFilesSummary from kagglesdk.kaggle_http_client import KaggleHttpClient @@ -21,6 +21,18 @@ def list_competitions(self, request: ApiListCompetitionsRequest = None) -> ApiLi return self._client.call("competitions.CompetitionApiService", "ListCompetitions", request, ApiListCompetitionsResponse) + def create_competition(self, request: ApiCreateCompetitionRequest = None) -> ApiCreateCompetitionResponse: + r""" + Args: + request (ApiCreateCompetitionRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiCreateCompetitionRequest() + + return self._client.call("competitions.CompetitionApiService", "CreateCompetition", request, ApiCreateCompetitionResponse) + def list_submissions(self, request: ApiListSubmissionsRequest = None) -> ApiListSubmissionsResponse: r""" Args: @@ -237,6 +249,30 @@ def list_competition_pages(self, request: ApiListCompetitionPagesRequest = None) return self._client.call("competitions.CompetitionApiService", "ListCompetitionPages", request, ApiListCompetitionPagesResponse) + def create_competition_page(self, request: ApiCreateCompetitionPageRequest = None) -> ApiCompetitionPage: + r""" + Args: + request (ApiCreateCompetitionPageRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiCreateCompetitionPageRequest() + + return self._client.call("competitions.CompetitionApiService", "CreateCompetitionPage", request, ApiCompetitionPage) + + def launch_competition(self, request: ApiLaunchCompetitionRequest = None): + r""" + Args: + request (ApiLaunchCompetitionRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiLaunchCompetitionRequest() + + self._client.call("competitions.CompetitionApiService", "LaunchCompetition", request, None) + def list_competition_topics(self, request: ApiListCompetitionTopicsRequest = None) -> ApiListCompetitionTopicsResponse: r""" Args: diff --git a/kagglesdk/competitions/services/episode_service.py b/kagglesdk/competitions/services/episode_service.py new file mode 100644 index 0000000..a99896e --- /dev/null +++ b/kagglesdk/competitions/services/episode_service.py @@ -0,0 +1,169 @@ +from kagglesdk.competitions.types.episode import Episode +from kagglesdk.competitions.types.episode_service import BulkCancelEpisodesRequest, BulkSetEpisodeRewardsRequest, BulkSetEpisodeRewardsResponse, CancelEpisodeRequest, CreateEpisodeRequest, GenerateEpisodesForCompetitionRequest, GenerateEpisodesForCompetitionResponse, GetEpisodeRequest, GetEpisodeResponse, GetEpisodeSummaryRequest, GetEpisodeSummaryResponse, ListEpisodesFromCompetitionRequest, ListEpisodesFromCompetitionResponse, ListEpisodesRequest, ListEpisodesResponse, ListValidationEpisodesRequest, ListValidationEpisodesResponse, MarkEnvironmentSubmissionValidatedRequest, SetEpisodeErroredRequest +from kagglesdk.kaggle_http_client import KaggleHttpClient + +class EpisodeClient(object): + + def __init__(self, client: KaggleHttpClient): + self._client = client + + def create_episode(self, request: CreateEpisodeRequest = None) -> Episode: + r""" + Args: + request (CreateEpisodeRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = CreateEpisodeRequest() + + return self._client.call("competitions.EpisodeService", "CreateEpisode", request, Episode) + + def generate_episodes_for_competition(self, request: GenerateEpisodesForCompetitionRequest = None) -> GenerateEpisodesForCompetitionResponse: + r""" + For a given Sims Comp, kick off some new Episodes. Intended for use + by the GenerateEpisodes scheduled handler (see below). + + Args: + request (GenerateEpisodesForCompetitionRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = GenerateEpisodesForCompetitionRequest() + + return self._client.call("competitions.EpisodeService", "GenerateEpisodesForCompetition", request, GenerateEpisodesForCompetitionResponse) + + def get_episode(self, request: GetEpisodeRequest = None) -> GetEpisodeResponse: + r""" + Args: + request (GetEpisodeRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = GetEpisodeRequest() + + return self._client.call("competitions.EpisodeService", "GetEpisode", request, GetEpisodeResponse) + + def list_episodes(self, request: ListEpisodesRequest = None) -> ListEpisodesResponse: + r""" + Lists Episodes of type Completed for a given filter. Currently top 1000 + only, by most recent EndTime. + + Args: + request (ListEpisodesRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ListEpisodesRequest() + + return self._client.call("competitions.EpisodeService", "ListEpisodes", request, ListEpisodesResponse) + + def set_episode_errored(self, request: SetEpisodeErroredRequest = None): + r""" + Args: + request (SetEpisodeErroredRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = SetEpisodeErroredRequest() + + self._client.call("competitions.EpisodeService", "SetEpisodeErrored", request, None) + + def bulk_set_episode_rewards(self, request: BulkSetEpisodeRewardsRequest = None) -> BulkSetEpisodeRewardsResponse: + r""" + Admin-only bulk action: invokes SetEpisodeRewards for every episode that + matches the provided filter. Defaults to dry_run = true, in which case the + matching episodes are counted but not processed. + + Args: + request (BulkSetEpisodeRewardsRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = BulkSetEpisodeRewardsRequest() + + return self._client.call("competitions.EpisodeService", "BulkSetEpisodeRewards", request, BulkSetEpisodeRewardsResponse) + + def cancel_episode(self, request: CancelEpisodeRequest = None): + r""" + Args: + request (CancelEpisodeRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = CancelEpisodeRequest() + + self._client.call("competitions.EpisodeService", "CancelEpisode", request, None) + + def bulk_cancel_episodes(self, request: BulkCancelEpisodesRequest = None): + r""" + Args: + request (BulkCancelEpisodesRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = BulkCancelEpisodesRequest() + + self._client.call("competitions.EpisodeService", "BulkCancelEpisodes", request, None) + + def list_episodes_from_competition(self, request: ListEpisodesFromCompetitionRequest = None) -> ListEpisodesFromCompetitionResponse: + r""" + List all episodes from a provided competition + + Args: + request (ListEpisodesFromCompetitionRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ListEpisodesFromCompetitionRequest() + + return self._client.call("competitions.EpisodeService", "ListEpisodesFromCompetition", request, ListEpisodesFromCompetitionResponse) + + def get_episode_summary(self, request: GetEpisodeSummaryRequest = None) -> GetEpisodeSummaryResponse: + r""" + Returns per-EpisodeType counts of recent episode activity for a single + competition: started in the last 24h, currently in-flight, completed in + the last 24h, and errored in the last 24h. Backs the admin 'Episode + Summary' tab. + + Args: + request (GetEpisodeSummaryRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = GetEpisodeSummaryRequest() + + return self._client.call("competitions.EpisodeService", "GetEpisodeSummary", request, GetEpisodeSummaryResponse) + + def list_validation_episodes(self, request: ListValidationEpisodesRequest = None) -> ListValidationEpisodesResponse: + r""" + Args: + request (ListValidationEpisodesRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ListValidationEpisodesRequest() + + return self._client.call("competitions.EpisodeService", "ListValidationEpisodes", request, ListValidationEpisodesResponse) + + def mark_environment_submission_validated(self, request: MarkEnvironmentSubmissionValidatedRequest = None): + r""" + Args: + request (MarkEnvironmentSubmissionValidatedRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = MarkEnvironmentSubmissionValidatedRequest() + + self._client.call("competitions.EpisodeService", "MarkEnvironmentSubmissionValidated", request, None) diff --git a/kagglesdk/competitions/services/host_service.py b/kagglesdk/competitions/services/host_service.py new file mode 100644 index 0000000..d7d5327 --- /dev/null +++ b/kagglesdk/competitions/services/host_service.py @@ -0,0 +1,398 @@ +from kagglesdk.competitions.types.competition_types import DatabundleBasicInfo, PrivacySettings +from kagglesdk.competitions.types.host_service import AddHostUserRequest, ClaimCompetitionSyntheticCopyRequest, ClaimCompetitionSyntheticCopyResponse, CreateCompetitionEmailInvitesRequest, CreateCompetitionEmailInvitesResponse, CreateCompetitionRequest, CreateCompetitionResponse, CreateCompetitionSampleSubmissionRequest, CreateCompetitionSolutionRequest, CreateHarnessKernelRequest, CreateHarnessKernelResponse, DeleteCompetitionEmailInviteRequest, DeleteCompetitionRequest, DeleteCompetitionResponse, DeleteSolutionFilesRequest, GetCompetitionSimulationSettingsRequest, GetDatabundleBasicInfoRequest, GetPrivacySettingsRequest, LaunchCompetitionRequest, ListCompetitionEmailInvitesRequest, ListCompetitionEmailInvitesResponse, ListCompetitionLicensesRequest, ListCompetitionLicensesResponse, ListHostUsersRequest, ListHostUsersResponse, RegenerateShareTokenRequest, RemoveHostUserRequest, SetCompetitionCitationAuthorsRequest, SetCompetitionMetricRequest, SetCompetitionMetricResponse, SetEvaluationMetricParametersRequest, ToggleBenchmarkSubmissionRequest, UpdateCompetitionSettingsRequest, UpdateCompetitionSettingsResponse, UpdateCompetitionSimulationSettingsRequest, UpdateCurrentCompetitionMetricVersionRequest, UpdateCurrentCompetitionMetricVersionResponse, UpdateImagesRequest, UpdateImagesResponse, UpdateSandboxSubmissionNameRequest, UpdateTeamsVisibilityRequest +from kagglesdk.competitions.types.simulations import CompetitionSimulationSettings +from kagglesdk.kaggle_http_client import KaggleHttpClient + +class HostClient(object): + """Contains methods related to hosting competitions.""" + + def __init__(self, client: KaggleHttpClient): + self._client = client + + def create_competition(self, request: CreateCompetitionRequest = None) -> CreateCompetitionResponse: + r""" + Creates a new (unlaunched) competition. + (-- aip.dev/not-precedent: Returning Competition wrapped in a Response --) + + Args: + request (CreateCompetitionRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = CreateCompetitionRequest() + + return self._client.call("competitions.HostService", "CreateCompetition", request, CreateCompetitionResponse) + + def delete_competition(self, request: DeleteCompetitionRequest = None) -> DeleteCompetitionResponse: + r""" + Args: + request (DeleteCompetitionRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = DeleteCompetitionRequest() + + return self._client.call("competitions.HostService", "DeleteCompetition", request, DeleteCompetitionResponse) + + def list_competition_licenses(self, request: ListCompetitionLicensesRequest = None) -> ListCompetitionLicensesResponse: + r""" + These RPCs support various tabs on the host wizard: + + Args: + request (ListCompetitionLicensesRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ListCompetitionLicensesRequest() + + return self._client.call("competitions.HostService", "ListCompetitionLicenses", request, ListCompetitionLicensesResponse) + + def get_privacy_settings(self, request: GetPrivacySettingsRequest = None) -> PrivacySettings: + r""" + 'Privacy' tab: + + Args: + request (GetPrivacySettingsRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = GetPrivacySettingsRequest() + + return self._client.call("competitions.HostService", "GetPrivacySettings", request, PrivacySettings) + + def list_competition_email_invites(self, request: ListCompetitionEmailInvitesRequest = None) -> ListCompetitionEmailInvitesResponse: + r""" + Args: + request (ListCompetitionEmailInvitesRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ListCompetitionEmailInvitesRequest() + + return self._client.call("competitions.HostService", "ListCompetitionEmailInvites", request, ListCompetitionEmailInvitesResponse) + + def delete_competition_email_invite(self, request: DeleteCompetitionEmailInviteRequest = None): + r""" + Args: + request (DeleteCompetitionEmailInviteRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = DeleteCompetitionEmailInviteRequest() + + self._client.call("competitions.HostService", "DeleteCompetitionEmailInvite", request, None) + + def create_competition_email_invite(self, request: CreateCompetitionEmailInvitesRequest = None) -> CreateCompetitionEmailInvitesResponse: + r""" + TODO(aip.dev/133): (-- api-linter: + core::0133::request-message-name=disabled --) + + Args: + request (CreateCompetitionEmailInvitesRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = CreateCompetitionEmailInvitesRequest() + + return self._client.call("competitions.HostService", "CreateCompetitionEmailInvite", request, CreateCompetitionEmailInvitesResponse) + + def create_competition_sample_submission(self, request: CreateCompetitionSampleSubmissionRequest = None): + r""" + Evaluation tab + + Args: + request (CreateCompetitionSampleSubmissionRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = CreateCompetitionSampleSubmissionRequest() + + self._client.call("competitions.HostService", "CreateCompetitionSampleSubmission", request, None) + + def create_competition_solution(self, request: CreateCompetitionSolutionRequest = None): + r""" + Args: + request (CreateCompetitionSolutionRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = CreateCompetitionSolutionRequest() + + self._client.call("competitions.HostService", "CreateCompetitionSolution", request, None) + + def toggle_benchmark_submission(self, request: ToggleBenchmarkSubmissionRequest = None): + r""" + Args: + request (ToggleBenchmarkSubmissionRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ToggleBenchmarkSubmissionRequest() + + self._client.call("competitions.HostService", "ToggleBenchmarkSubmission", request, None) + + def update_sandbox_submission_name(self, request: UpdateSandboxSubmissionNameRequest = None): + r""" + Args: + request (UpdateSandboxSubmissionNameRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = UpdateSandboxSubmissionNameRequest() + + self._client.call("competitions.HostService", "UpdateSandboxSubmissionName", request, None) + + def delete_solution_files(self, request: DeleteSolutionFilesRequest = None): + r""" + Args: + request (DeleteSolutionFilesRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = DeleteSolutionFilesRequest() + + self._client.call("competitions.HostService", "DeleteSolutionFiles", request, None) + + def regenerate_share_token(self, request: RegenerateShareTokenRequest = None) -> PrivacySettings: + r""" + This keeps existing UI behavior, but it could be refactored into the + UpdatePrivacySettings RPC above with a convention like setting it to + 'regenerate' would cause it to be regenerated. + + Args: + request (RegenerateShareTokenRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = RegenerateShareTokenRequest() + + return self._client.call("competitions.HostService", "RegenerateShareToken", request, PrivacySettings) + + def set_competition_metric(self, request: SetCompetitionMetricRequest = None) -> SetCompetitionMetricResponse: + r""" + TODO(aip.dev/134): (-- api-linter: core::0134::synonyms=disabled --) + + Args: + request (SetCompetitionMetricRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = SetCompetitionMetricRequest() + + return self._client.call("competitions.HostService", "SetCompetitionMetric", request, SetCompetitionMetricResponse) + + def update_current_competition_metric_version(self, request: UpdateCurrentCompetitionMetricVersionRequest = None) -> UpdateCurrentCompetitionMetricVersionResponse: + r""" + Args: + request (UpdateCurrentCompetitionMetricVersionRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = UpdateCurrentCompetitionMetricVersionRequest() + + return self._client.call("competitions.HostService", "UpdateCurrentCompetitionMetricVersion", request, UpdateCurrentCompetitionMetricVersionResponse) + + def claim_competition_synthetic_copy(self, request: ClaimCompetitionSyntheticCopyRequest = None) -> ClaimCompetitionSyntheticCopyResponse: + r""" + Allows claiming a copy of the specified base competition with unique + synthetic data (if available) + go/kaggle-competition-datasets-on-demand + + Args: + request (ClaimCompetitionSyntheticCopyRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ClaimCompetitionSyntheticCopyRequest() + + return self._client.call("competitions.HostService", "ClaimCompetitionSyntheticCopy", request, ClaimCompetitionSyntheticCopyResponse) + + def get_databundle_basic_info(self, request: GetDatabundleBasicInfoRequest = None) -> DatabundleBasicInfo: + r""" + For each file in the competition's public databundle, returns file names, + sizes, and dimensions. Also returns total size and whether any directories + exist. + + Args: + request (GetDatabundleBasicInfoRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = GetDatabundleBasicInfoRequest() + + return self._client.call("competitions.HostService", "GetDatabundleBasicInfo", request, DatabundleBasicInfo) + + def set_competition_citation_authors(self, request: SetCompetitionCitationAuthorsRequest = None): + r""" + Args: + request (SetCompetitionCitationAuthorsRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = SetCompetitionCitationAuthorsRequest() + + self._client.call("competitions.HostService", "SetCompetitionCitationAuthors", request, None) + + def add_host_user(self, request: AddHostUserRequest = None): + r""" + Args: + request (AddHostUserRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = AddHostUserRequest() + + self._client.call("competitions.HostService", "AddHostUser", request, None) + + def remove_host_user(self, request: RemoveHostUserRequest = None): + r""" + Args: + request (RemoveHostUserRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = RemoveHostUserRequest() + + self._client.call("competitions.HostService", "RemoveHostUser", request, None) + + def list_host_users(self, request: ListHostUsersRequest = None) -> ListHostUsersResponse: + r""" + Args: + request (ListHostUsersRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ListHostUsersRequest() + + return self._client.call("competitions.HostService", "ListHostUsers", request, ListHostUsersResponse) + + def update_images(self, request: UpdateImagesRequest = None) -> UpdateImagesResponse: + r""" + Updates the header and/or thumbnail images associated with the competition. + + Args: + request (UpdateImagesRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = UpdateImagesRequest() + + return self._client.call("competitions.HostService", "UpdateImages", request, UpdateImagesResponse) + + def update_competition_settings(self, request: UpdateCompetitionSettingsRequest = None) -> UpdateCompetitionSettingsResponse: + r""" + Args: + request (UpdateCompetitionSettingsRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = UpdateCompetitionSettingsRequest() + + return self._client.call("competitions.HostService", "UpdateCompetitionSettings", request, UpdateCompetitionSettingsResponse) + + def update_competition_simulation_settings(self, request: UpdateCompetitionSimulationSettingsRequest = None) -> CompetitionSimulationSettings: + r""" + Args: + request (UpdateCompetitionSimulationSettingsRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = UpdateCompetitionSimulationSettingsRequest() + + return self._client.call("competitions.HostService", "UpdateCompetitionSimulationSettings", request, CompetitionSimulationSettings) + + def get_competition_simulation_settings(self, request: GetCompetitionSimulationSettingsRequest = None) -> CompetitionSimulationSettings: + r""" + Args: + request (GetCompetitionSimulationSettingsRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = GetCompetitionSimulationSettingsRequest() + + return self._client.call("competitions.HostService", "GetCompetitionSimulationSettings", request, CompetitionSimulationSettings) + + def update_teams_visibility(self, request: UpdateTeamsVisibilityRequest = None): + r""" + Args: + request (UpdateTeamsVisibilityRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = UpdateTeamsVisibilityRequest() + + self._client.call("competitions.HostService", "UpdateTeamsVisibility", request, None) + + def launch_competition(self, request: LaunchCompetitionRequest = None): + r""" + Launch the competition (or set it to be launched in the future) so that it + becomes visible to participants. + + Args: + request (LaunchCompetitionRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = LaunchCompetitionRequest() + + self._client.call("competitions.HostService", "LaunchCompetition", request, None) + + def set_evaluation_metric_parameters(self, request: SetEvaluationMetricParametersRequest = None): + r""" + Args: + request (SetEvaluationMetricParametersRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = SetEvaluationMetricParametersRequest() + + self._client.call("competitions.HostService", "SetEvaluationMetricParameters", request, None) + + def create_harness_kernel(self, request: CreateHarnessKernelRequest = None) -> CreateHarnessKernelResponse: + r""" + Creates a Python script kernel owned by the Competition Metric bot + (UserId.MetricUserId) to serve as the harness notebook for a Game Arena + competition. If github_source is set, seeds the kernel with the contents + of that file and stamps the corresponding GithubSpec so the kernel editor + shows it as linked to GitHub. The created kernel is NOT attached to the + competition as a data source (that would mark it a submission notebook); + callers are expected to wire it up via + UpdateCompetitionSimulationSettings.HarnessKernelId. + + Args: + request (CreateHarnessKernelRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = CreateHarnessKernelRequest() + + return self._client.call("competitions.HostService", "CreateHarnessKernel", request, CreateHarnessKernelResponse) diff --git a/kagglesdk/competitions/types/competition.py b/kagglesdk/competitions/types/competition.py index d75e455..e891ce0 100644 --- a/kagglesdk/competitions/types/competition.py +++ b/kagglesdk/competitions/types/competition.py @@ -1,4 +1,6 @@ import enum +from kagglesdk.kaggle_object import * +from typing import Optional class RewardTypeId(enum.Enum): REWARD_TYPE_ID_UNSPECIFIED = 0 @@ -12,3 +14,66 @@ class RewardTypeId(enum.Enum): KNOWLEDGE = 8 PRIZES = 9 +class Reward(KaggleObject): + r""" + TODO(b/350786629): make the DB change to set RewardTypeId and rewardQuantity + default to 0 and change rewardQuantity type from decimal to int. + + Attributes: + id (RewardTypeId) + quantity (int) + clarification (str) + """ + + def __init__(self): + self._id = RewardTypeId.REWARD_TYPE_ID_UNSPECIFIED + self._quantity = 0 + self._clarification = None + self._freeze() + + @property + def id(self) -> 'RewardTypeId': + return self._id + + @id.setter + def id(self, id: 'RewardTypeId'): + if id is None: + del self.id + return + if not isinstance(id, RewardTypeId): + raise TypeError('id must be of type RewardTypeId') + self._id = id + + @property + def quantity(self) -> int: + return self._quantity + + @quantity.setter + def quantity(self, quantity: int): + if quantity is None: + del self.quantity + return + if not isinstance(quantity, int): + raise TypeError('quantity must be of type int') + self._quantity = quantity + + @property + def clarification(self) -> str: + return self._clarification or "" + + @clarification.setter + def clarification(self, clarification: Optional[str]): + if clarification is None: + del self.clarification + return + if not isinstance(clarification, str): + raise TypeError('clarification must be of type str') + self._clarification = clarification + + +Reward._fields = [ + FieldMetadata("id", "id", "_id", RewardTypeId, RewardTypeId.REWARD_TYPE_ID_UNSPECIFIED, EnumSerializer()), + FieldMetadata("quantity", "quantity", "_quantity", int, 0, PredefinedSerializer()), + FieldMetadata("clarification", "clarification", "_clarification", str, None, PredefinedSerializer(), optional=True), +] + diff --git a/kagglesdk/competitions/types/competition_api_service.py b/kagglesdk/competitions/types/competition_api_service.py index 7f2cec7..e9f889f 100644 --- a/kagglesdk/competitions/types/competition_api_service.py +++ b/kagglesdk/competitions/types/competition_api_service.py @@ -1,5 +1,6 @@ from datetime import datetime -from kagglesdk.competitions.types.competition_enums import CompetitionListTab, CompetitionSortBy, HostSegment, SubmissionGroup, SubmissionSortBy +from kagglesdk.competitions.types.competition import Reward +from kagglesdk.competitions.types.competition_enums import CompetitionListTab, CompetitionPrivacy, CompetitionSortBy, HostSegment, SubmissionGroup, SubmissionSortBy from kagglesdk.competitions.types.episode import EpisodeAgentState, EpisodeState, EpisodeType from kagglesdk.competitions.types.submission_status import SubmissionStatus from kagglesdk.discussions.types.discussions_enums import CommentListSortBy, TopicListSortBy @@ -555,17 +556,31 @@ def date_created(self, date_created: datetime): class ApiCompetitionPage(KaggleObject): r""" + NOTE: writable field names must stay in sync with `kaggle.competitions.Page` + — UpdateCompetitionPage forwards the mask verbatim to UpdatePage. + Attributes: name (str) Page name (e.g. 'description', 'rules', 'evaluation', 'data-description', 'prizes'). content (str) The rendered content of the page. + is_published (bool) + Whether the page is publicly visible. Defaults to false on create so hosts + can stage content before publishing. + post_title (str) + Optional post title shown above the page content. Defaults to the page + name on create. + mime_type (str) + MIME type of `content`. Defaults to 'text/html' on create. """ def __init__(self): self._name = "" self._content = "" + self._is_published = None + self._post_title = None + self._mime_type = None self._freeze() @property @@ -599,6 +614,54 @@ def content(self, content: str): raise TypeError('content must be of type str') self._content = content + @property + def is_published(self) -> bool: + r""" + Whether the page is publicly visible. Defaults to false on create so hosts + can stage content before publishing. + """ + return self._is_published or False + + @is_published.setter + def is_published(self, is_published: Optional[bool]): + if is_published is None: + del self.is_published + return + if not isinstance(is_published, bool): + raise TypeError('is_published must be of type bool') + self._is_published = is_published + + @property + def post_title(self) -> str: + r""" + Optional post title shown above the page content. Defaults to the page + name on create. + """ + return self._post_title or "" + + @post_title.setter + def post_title(self, post_title: Optional[str]): + if post_title is None: + del self.post_title + return + if not isinstance(post_title, str): + raise TypeError('post_title must be of type str') + self._post_title = post_title + + @property + def mime_type(self) -> str: + """MIME type of `content`. Defaults to 'text/html' on create.""" + return self._mime_type or "" + + @mime_type.setter + def mime_type(self, mime_type: Optional[str]): + if mime_type is None: + del self.mime_type + return + if not isinstance(mime_type, str): + raise TypeError('mime_type must be of type str') + self._mime_type = mime_type + class ApiCompetitionTopic(KaggleObject): r""" @@ -891,6 +954,404 @@ def ref(self, ref: int): self._ref = ref +class ApiCreateCompetitionPageRequest(KaggleObject): + r""" + Attributes: + competition_name (str) + page (ApiCompetitionPage) + """ + + def __init__(self): + self._competition_name = "" + self._page = None + self._freeze() + + @property + def competition_name(self) -> str: + return self._competition_name + + @competition_name.setter + def competition_name(self, competition_name: str): + if competition_name is None: + del self.competition_name + return + if not isinstance(competition_name, str): + raise TypeError('competition_name must be of type str') + self._competition_name = competition_name + + @property + def page(self) -> Optional['ApiCompetitionPage']: + return self._page + + @page.setter + def page(self, page: Optional['ApiCompetitionPage']): + if page is None: + del self.page + return + if not isinstance(page, ApiCompetitionPage): + raise TypeError('page must be of type ApiCompetitionPage') + self._page = page + + def endpoint(self): + path = '/api/v1/competitions/{competition_name}/pages' + return path.format_map(self.to_field_map(self)) + + + @staticmethod + def method(): + return 'POST' + + @staticmethod + def body_fields(): + return '*' + + +class ApiCreateCompetitionRequest(KaggleObject): + r""" + Attributes: + title (str) + Required. The competition's display title. + slug (str) + Required. URL slug; must be unique site-wide. Lowercase, hyphens, must not + be all digits or all hyphens. + brief_description (str) + Required. One-line subtitle shown under the title. + privacy (CompetitionPrivacy) + Required. Visibility — PUBLIC, LIMITED, or PRIVATE. + clone_competition_id (int) + Optional. If set, clone configuration / pages / data / evaluation setup + from this competition. + disable_kernels (bool) + Optional. If true, notebook submissions are disabled. + restrict_link_to_email_list (bool) + Optional. Restrict invite-link joiners to a host-maintained allowlist of + emails/domains. + license_id (int) + Optional. License ID for the competition data. See ListCompetitionLicenses. + organization_id (int) + Optional. Tie this competition to an organization (grants read-only access + to all org members). + clone_exclude_competition_data (bool) + Optional. If cloning, skip copying the data (solution, sandbox + submissions, images, databundles). + clone_page_names (str) + Optional. If cloning, only copy these page names. Empty = copy all. + reward (Reward) + Optional. Prize / reward summary. + hackathon (bool) + Optional. Create as a hackathon competition. + num_prizes (int) + Optional. Number of leaderboard prize positions. + """ + + def __init__(self): + self._title = "" + self._slug = "" + self._brief_description = "" + self._privacy = CompetitionPrivacy.COMPETITION_PRIVACY_UNSPECIFIED + self._clone_competition_id = None + self._disable_kernels = None + self._restrict_link_to_email_list = None + self._license_id = None + self._organization_id = None + self._clone_exclude_competition_data = None + self._clone_page_names = [] + self._reward = None + self._hackathon = None + self._num_prizes = None + self._freeze() + + @property + def title(self) -> str: + """Required. The competition's display title.""" + return self._title + + @title.setter + def title(self, title: str): + if title is None: + del self.title + return + if not isinstance(title, str): + raise TypeError('title must be of type str') + self._title = title + + @property + def slug(self) -> str: + r""" + Required. URL slug; must be unique site-wide. Lowercase, hyphens, must not + be all digits or all hyphens. + """ + return self._slug + + @slug.setter + def slug(self, slug: str): + if slug is None: + del self.slug + return + if not isinstance(slug, str): + raise TypeError('slug must be of type str') + self._slug = slug + + @property + def brief_description(self) -> str: + """Required. One-line subtitle shown under the title.""" + return self._brief_description + + @brief_description.setter + def brief_description(self, brief_description: str): + if brief_description is None: + del self.brief_description + return + if not isinstance(brief_description, str): + raise TypeError('brief_description must be of type str') + self._brief_description = brief_description + + @property + def privacy(self) -> 'CompetitionPrivacy': + """Required. Visibility — PUBLIC, LIMITED, or PRIVATE.""" + return self._privacy + + @privacy.setter + def privacy(self, privacy: 'CompetitionPrivacy'): + if privacy is None: + del self.privacy + return + if not isinstance(privacy, CompetitionPrivacy): + raise TypeError('privacy must be of type CompetitionPrivacy') + self._privacy = privacy + + @property + def clone_competition_id(self) -> int: + r""" + Optional. If set, clone configuration / pages / data / evaluation setup + from this competition. + """ + return self._clone_competition_id or 0 + + @clone_competition_id.setter + def clone_competition_id(self, clone_competition_id: Optional[int]): + if clone_competition_id is None: + del self.clone_competition_id + return + if not isinstance(clone_competition_id, int): + raise TypeError('clone_competition_id must be of type int') + self._clone_competition_id = clone_competition_id + + @property + def disable_kernels(self) -> bool: + """Optional. If true, notebook submissions are disabled.""" + return self._disable_kernels or False + + @disable_kernels.setter + def disable_kernels(self, disable_kernels: Optional[bool]): + if disable_kernels is None: + del self.disable_kernels + return + if not isinstance(disable_kernels, bool): + raise TypeError('disable_kernels must be of type bool') + self._disable_kernels = disable_kernels + + @property + def restrict_link_to_email_list(self) -> bool: + r""" + Optional. Restrict invite-link joiners to a host-maintained allowlist of + emails/domains. + """ + return self._restrict_link_to_email_list or False + + @restrict_link_to_email_list.setter + def restrict_link_to_email_list(self, restrict_link_to_email_list: Optional[bool]): + if restrict_link_to_email_list is None: + del self.restrict_link_to_email_list + return + if not isinstance(restrict_link_to_email_list, bool): + raise TypeError('restrict_link_to_email_list must be of type bool') + self._restrict_link_to_email_list = restrict_link_to_email_list + + @property + def license_id(self) -> int: + """Optional. License ID for the competition data. See ListCompetitionLicenses.""" + return self._license_id or 0 + + @license_id.setter + def license_id(self, license_id: Optional[int]): + if license_id is None: + del self.license_id + return + if not isinstance(license_id, int): + raise TypeError('license_id must be of type int') + self._license_id = license_id + + @property + def organization_id(self) -> int: + r""" + Optional. Tie this competition to an organization (grants read-only access + to all org members). + """ + return self._organization_id or 0 + + @organization_id.setter + def organization_id(self, organization_id: Optional[int]): + if organization_id is None: + del self.organization_id + return + if not isinstance(organization_id, int): + raise TypeError('organization_id must be of type int') + self._organization_id = organization_id + + @property + def clone_exclude_competition_data(self) -> bool: + r""" + Optional. If cloning, skip copying the data (solution, sandbox + submissions, images, databundles). + """ + return self._clone_exclude_competition_data or False + + @clone_exclude_competition_data.setter + def clone_exclude_competition_data(self, clone_exclude_competition_data: Optional[bool]): + if clone_exclude_competition_data is None: + del self.clone_exclude_competition_data + return + if not isinstance(clone_exclude_competition_data, bool): + raise TypeError('clone_exclude_competition_data must be of type bool') + self._clone_exclude_competition_data = clone_exclude_competition_data + + @property + def clone_page_names(self) -> Optional[List[str]]: + """Optional. If cloning, only copy these page names. Empty = copy all.""" + return self._clone_page_names + + @clone_page_names.setter + def clone_page_names(self, clone_page_names: Optional[List[str]]): + if clone_page_names is None: + del self.clone_page_names + return + if not isinstance(clone_page_names, list): + raise TypeError('clone_page_names must be of type list') + if not all([isinstance(t, str) for t in clone_page_names]): + raise TypeError('clone_page_names must contain only items of type str') + self._clone_page_names = clone_page_names + + @property + def reward(self) -> Optional['Reward']: + """Optional. Prize / reward summary.""" + return self._reward or None + + @reward.setter + def reward(self, reward: Optional[Optional['Reward']]): + if reward is None: + del self.reward + return + if not isinstance(reward, Reward): + raise TypeError('reward must be of type Reward') + self._reward = reward + + @property + def hackathon(self) -> bool: + """Optional. Create as a hackathon competition.""" + return self._hackathon or False + + @hackathon.setter + def hackathon(self, hackathon: Optional[bool]): + if hackathon is None: + del self.hackathon + return + if not isinstance(hackathon, bool): + raise TypeError('hackathon must be of type bool') + self._hackathon = hackathon + + @property + def num_prizes(self) -> int: + """Optional. Number of leaderboard prize positions.""" + return self._num_prizes or 0 + + @num_prizes.setter + def num_prizes(self, num_prizes: Optional[int]): + if num_prizes is None: + del self.num_prizes + return + if not isinstance(num_prizes, int): + raise TypeError('num_prizes must be of type int') + self._num_prizes = num_prizes + + def endpoint(self): + path = '/api/v1/competitions' + return path.format_map(self.to_field_map(self)) + + + @staticmethod + def method(): + return 'POST' + + @staticmethod + def body_fields(): + return '*' + + +class ApiCreateCompetitionResponse(KaggleObject): + r""" + Attributes: + id (int) + The created competition's numeric ID. + ref (str) + Normalized URL slug of the created competition (lowercased; may differ + from the input `slug`, which is normalized server-side). + url (str) + Full URL to the new competition (https:///competitions/). + """ + + def __init__(self): + self._id = 0 + self._ref = "" + self._url = "" + self._freeze() + + @property + def id(self) -> int: + """The created competition's numeric ID.""" + return self._id + + @id.setter + def id(self, id: int): + if id is None: + del self.id + return + if not isinstance(id, int): + raise TypeError('id must be of type int') + self._id = id + + @property + def ref(self) -> str: + r""" + Normalized URL slug of the created competition (lowercased; may differ + from the input `slug`, which is normalized server-side). + """ + return self._ref + + @ref.setter + def ref(self, ref: str): + if ref is None: + del self.ref + return + if not isinstance(ref, str): + raise TypeError('ref must be of type str') + self._ref = ref + + @property + def url(self) -> str: + """Full URL to the new competition (https:///competitions/).""" + return self._url + + @url.setter + def url(self, url: str): + if url is None: + del self.url + return + if not isinstance(url, str): + raise TypeError('url must be of type str') + self._url = url + + class ApiCreateSubmissionRequest(KaggleObject): r""" Attributes: @@ -1775,6 +2236,64 @@ def method(): return 'POST' +class ApiLaunchCompetitionRequest(KaggleObject): + r""" + Attributes: + competition_name (str) + future_time (datetime) + Optional. UTC time in the future at which to launch the competition. If + omitted, the competition launches immediately. + """ + + def __init__(self): + self._competition_name = "" + self._future_time = None + self._freeze() + + @property + def competition_name(self) -> str: + return self._competition_name + + @competition_name.setter + def competition_name(self, competition_name: str): + if competition_name is None: + del self.competition_name + return + if not isinstance(competition_name, str): + raise TypeError('competition_name must be of type str') + self._competition_name = competition_name + + @property + def future_time(self) -> datetime: + r""" + Optional. UTC time in the future at which to launch the competition. If + omitted, the competition launches immediately. + """ + return self._future_time + + @future_time.setter + def future_time(self, future_time: datetime): + if future_time is None: + del self.future_time + return + if not isinstance(future_time, datetime): + raise TypeError('future_time must be of type datetime') + self._future_time = future_time + + def endpoint(self): + path = '/api/v1/competitions/{competition_name}/launch' + return path.format_map(self.to_field_map(self)) + + + @staticmethod + def method(): + return 'POST' + + @staticmethod + def body_fields(): + return '*' + + class ApiLeaderboardSubmission(KaggleObject): r""" Attributes: @@ -3404,6 +3923,9 @@ def replies(self, replies: Optional[List[Optional['ApiTopicMessage']]]): ApiCompetitionPage._fields = [ FieldMetadata("name", "name", "_name", str, "", PredefinedSerializer()), FieldMetadata("content", "content", "_content", str, "", PredefinedSerializer()), + FieldMetadata("isPublished", "is_published", "_is_published", bool, None, PredefinedSerializer(), optional=True), + FieldMetadata("postTitle", "post_title", "_post_title", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("mimeType", "mime_type", "_mime_type", str, None, PredefinedSerializer(), optional=True), ] ApiCompetitionTopic._fields = [ @@ -3432,6 +3954,34 @@ def replies(self, replies: Optional[List[Optional['ApiTopicMessage']]]): FieldMetadata("ref", "ref", "_ref", int, 0, PredefinedSerializer()), ] +ApiCreateCompetitionPageRequest._fields = [ + FieldMetadata("competitionName", "competition_name", "_competition_name", str, "", PredefinedSerializer()), + FieldMetadata("page", "page", "_page", ApiCompetitionPage, None, KaggleObjectSerializer()), +] + +ApiCreateCompetitionRequest._fields = [ + FieldMetadata("title", "title", "_title", str, "", PredefinedSerializer()), + FieldMetadata("slug", "slug", "_slug", str, "", PredefinedSerializer()), + FieldMetadata("briefDescription", "brief_description", "_brief_description", str, "", PredefinedSerializer()), + FieldMetadata("privacy", "privacy", "_privacy", CompetitionPrivacy, CompetitionPrivacy.COMPETITION_PRIVACY_UNSPECIFIED, EnumSerializer()), + FieldMetadata("cloneCompetitionId", "clone_competition_id", "_clone_competition_id", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("disableKernels", "disable_kernels", "_disable_kernels", bool, None, PredefinedSerializer(), optional=True), + FieldMetadata("restrictLinkToEmailList", "restrict_link_to_email_list", "_restrict_link_to_email_list", bool, None, PredefinedSerializer(), optional=True), + FieldMetadata("licenseId", "license_id", "_license_id", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("organizationId", "organization_id", "_organization_id", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("cloneExcludeCompetitionData", "clone_exclude_competition_data", "_clone_exclude_competition_data", bool, None, PredefinedSerializer(), optional=True), + FieldMetadata("clonePageNames", "clone_page_names", "_clone_page_names", str, [], ListSerializer(PredefinedSerializer())), + FieldMetadata("reward", "reward", "_reward", Reward, None, KaggleObjectSerializer(), optional=True), + FieldMetadata("hackathon", "hackathon", "_hackathon", bool, None, PredefinedSerializer(), optional=True), + FieldMetadata("numPrizes", "num_prizes", "_num_prizes", int, None, PredefinedSerializer(), optional=True), +] + +ApiCreateCompetitionResponse._fields = [ + FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()), + FieldMetadata("ref", "ref", "_ref", str, "", PredefinedSerializer()), + FieldMetadata("url", "url", "_url", str, "", PredefinedSerializer()), +] + ApiCreateSubmissionRequest._fields = [ FieldMetadata("competitionName", "competition_name", "_competition_name", str, "", PredefinedSerializer()), FieldMetadata("blobFileTokens", "blob_file_tokens", "_blob_file_tokens", str, "", PredefinedSerializer()), @@ -3518,6 +4068,11 @@ def replies(self, replies: Optional[List[Optional['ApiTopicMessage']]]): FieldMetadata("ref", "ref", "_ref", int, 0, PredefinedSerializer()), ] +ApiLaunchCompetitionRequest._fields = [ + FieldMetadata("competitionName", "competition_name", "_competition_name", str, "", PredefinedSerializer()), + FieldMetadata("futureTime", "future_time", "_future_time", datetime, None, DateTimeSerializer()), +] + ApiLeaderboardSubmission._fields = [ FieldMetadata("teamId", "team_id", "_team_id", int, 0, PredefinedSerializer()), FieldMetadata("teamName", "team_name", "_team_name", str, None, PredefinedSerializer(), optional=True), diff --git a/kagglesdk/competitions/types/competition_enums.py b/kagglesdk/competitions/types/competition_enums.py index 7531f99..cd47dde 100644 --- a/kagglesdk/competitions/types/competition_enums.py +++ b/kagglesdk/competitions/types/competition_enums.py @@ -10,6 +10,12 @@ class CompetitionListTab(enum.Enum): COMPETITION_LIST_TAB_UNLAUNCHED_COMMUNITY = 5 COMPETITION_LIST_TAB_EVERYTHING = 6 +class CompetitionPrivacy(enum.Enum): + COMPETITION_PRIVACY_UNSPECIFIED = 0 + PUBLIC = 1 + LIMITED = 2 + PRIVATE = 3 + class CompetitionSortBy(enum.Enum): COMPETITION_SORT_BY_GROUPED = 0 """TODO(aip.dev/126): (-- api-linter: core::0126::unspecified=disabled --)""" @@ -26,6 +32,7 @@ class HackathonTrackPrizeType(enum.Enum): HACKATHON_TRACK_PRIZE_TYPE_KUDOS = 1 HACKATHON_TRACK_PRIZE_TYPE_NON_MONETARY = 2 HACKATHON_TRACK_PRIZE_TYPE_MONETARY = 3 + HACKATHON_TRACK_PRIZE_TYPE_SWAG = 4 class HostSegment(enum.Enum): r""" diff --git a/kagglesdk/competitions/types/episode_service.py b/kagglesdk/competitions/types/episode_service.py new file mode 100644 index 0000000..76d87e1 --- /dev/null +++ b/kagglesdk/competitions/types/episode_service.py @@ -0,0 +1,1475 @@ +from kagglesdk.competitions.types.episode import Episode, EpisodeState, EpisodeType +from kagglesdk.competitions.types.submission import Submission +from kagglesdk.competitions.types.team import Team +from kagglesdk.kaggle_object import * +from typing import List, Optional, Dict + +class BenchmarkTaskVersionFilter(KaggleObject): + r""" + Attributes: + benchmark_task_version_id (int) + benchmark_model_version_id (int) + """ + + def __init__(self): + self._benchmark_task_version_id = 0 + self._benchmark_model_version_id = 0 + self._freeze() + + @property + def benchmark_task_version_id(self) -> int: + return self._benchmark_task_version_id + + @benchmark_task_version_id.setter + def benchmark_task_version_id(self, benchmark_task_version_id: int): + if benchmark_task_version_id is None: + del self.benchmark_task_version_id + return + if not isinstance(benchmark_task_version_id, int): + raise TypeError('benchmark_task_version_id must be of type int') + self._benchmark_task_version_id = benchmark_task_version_id + + @property + def benchmark_model_version_id(self) -> int: + return self._benchmark_model_version_id + + @benchmark_model_version_id.setter + def benchmark_model_version_id(self, benchmark_model_version_id: int): + if benchmark_model_version_id is None: + del self.benchmark_model_version_id + return + if not isinstance(benchmark_model_version_id, int): + raise TypeError('benchmark_model_version_id must be of type int') + self._benchmark_model_version_id = benchmark_model_version_id + + +class BulkCancelEpisodesRequest(KaggleObject): + r""" + Attributes: + episode_ids (int) + """ + + def __init__(self): + self._episode_ids = [] + self._freeze() + + @property + def episode_ids(self) -> Optional[List[int]]: + return self._episode_ids + + @episode_ids.setter + def episode_ids(self, episode_ids: Optional[List[int]]): + if episode_ids is None: + del self.episode_ids + return + if not isinstance(episode_ids, list): + raise TypeError('episode_ids must be of type list') + if not all([isinstance(t, int) for t in episode_ids]): + raise TypeError('episode_ids must contain only items of type int') + self._episode_ids = episode_ids + + +class BulkCreateEpisodeRequest(KaggleObject): + r""" + Attributes: + requests (CreateEpisodeRequest) + """ + + def __init__(self): + self._requests = [] + self._freeze() + + @property + def requests(self) -> Optional[List[Optional['CreateEpisodeRequest']]]: + return self._requests + + @requests.setter + def requests(self, requests: Optional[List[Optional['CreateEpisodeRequest']]]): + if requests is None: + del self.requests + return + if not isinstance(requests, list): + raise TypeError('requests must be of type list') + if not all([isinstance(t, CreateEpisodeRequest) for t in requests]): + raise TypeError('requests must contain only items of type CreateEpisodeRequest') + self._requests = requests + + +class BulkCreateEpisodeResponse(KaggleObject): + r""" + Attributes: + episodes (Episode) + """ + + def __init__(self): + self._episodes = [] + self._freeze() + + @property + def episodes(self) -> Optional[List[Optional['Episode']]]: + return self._episodes + + @episodes.setter + def episodes(self, episodes: Optional[List[Optional['Episode']]]): + if episodes is None: + del self.episodes + return + if not isinstance(episodes, list): + raise TypeError('episodes must be of type list') + if not all([isinstance(t, Episode) for t in episodes]): + raise TypeError('episodes must contain only items of type Episode') + self._episodes = episodes + + +class BulkSetEpisodeRewardsRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + Filter: only episodes in this competition are considered. + episode_state (EpisodeState) + Filter: only episodes in this state are considered. + dry_run (bool) + When true (default), matching episodes are counted but SetEpisodeRewards + is not invoked. When false, SetEpisodeRewards is invoked for each match. + min_age_hours (int) + Filter: only episodes created at least this many hours ago are considered. + Defaults to 0 (no minimum). Use this to exclude episodes that are still + running (e.g. set to 1+ when targeting CREATED episodes so freshly-started + ones don't get a premature rewards attempt against missing replays). + max_episodes (int) + Maximum number of episodes to update in a single call. Defaults to 1000 + when unspecified or 0, and is hard-capped at 10000 since SetEpisodeRewards + is invoked sequentially per match. Matching episodes are processed in + oldest-first order by create time, so re-running the call drains the + backlog from the oldest end. + """ + + def __init__(self): + self._competition_id = 0 + self._episode_state = EpisodeState.EPISODE_STATE_UNSPECIFIED + self._dry_run = False + self._min_age_hours = 0 + self._max_episodes = 0 + self._freeze() + + @property + def competition_id(self) -> int: + """Filter: only episodes in this competition are considered.""" + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + @property + def episode_state(self) -> 'EpisodeState': + """Filter: only episodes in this state are considered.""" + return self._episode_state + + @episode_state.setter + def episode_state(self, episode_state: 'EpisodeState'): + if episode_state is None: + del self.episode_state + return + if not isinstance(episode_state, EpisodeState): + raise TypeError('episode_state must be of type EpisodeState') + self._episode_state = episode_state + + @property + def dry_run(self) -> bool: + r""" + When true (default), matching episodes are counted but SetEpisodeRewards + is not invoked. When false, SetEpisodeRewards is invoked for each match. + """ + return self._dry_run + + @dry_run.setter + def dry_run(self, dry_run: bool): + if dry_run is None: + del self.dry_run + return + if not isinstance(dry_run, bool): + raise TypeError('dry_run must be of type bool') + self._dry_run = dry_run + + @property + def min_age_hours(self) -> int: + r""" + Filter: only episodes created at least this many hours ago are considered. + Defaults to 0 (no minimum). Use this to exclude episodes that are still + running (e.g. set to 1+ when targeting CREATED episodes so freshly-started + ones don't get a premature rewards attempt against missing replays). + """ + return self._min_age_hours + + @min_age_hours.setter + def min_age_hours(self, min_age_hours: int): + if min_age_hours is None: + del self.min_age_hours + return + if not isinstance(min_age_hours, int): + raise TypeError('min_age_hours must be of type int') + self._min_age_hours = min_age_hours + + @property + def max_episodes(self) -> int: + r""" + Maximum number of episodes to update in a single call. Defaults to 1000 + when unspecified or 0, and is hard-capped at 10000 since SetEpisodeRewards + is invoked sequentially per match. Matching episodes are processed in + oldest-first order by create time, so re-running the call drains the + backlog from the oldest end. + """ + return self._max_episodes + + @max_episodes.setter + def max_episodes(self, max_episodes: int): + if max_episodes is None: + del self.max_episodes + return + if not isinstance(max_episodes, int): + raise TypeError('max_episodes must be of type int') + self._max_episodes = max_episodes + + +class BulkSetEpisodeRewardsResponse(KaggleObject): + r""" + Attributes: + episodes_found (int) + Number of episodes matched by the filter. + episodes_processed (int) + Number of episodes for which SetEpisodeRewards was successfully invoked. + Always 0 when dry_run is true. + """ + + def __init__(self): + self._episodes_found = 0 + self._episodes_processed = 0 + self._freeze() + + @property + def episodes_found(self) -> int: + """Number of episodes matched by the filter.""" + return self._episodes_found + + @episodes_found.setter + def episodes_found(self, episodes_found: int): + if episodes_found is None: + del self.episodes_found + return + if not isinstance(episodes_found, int): + raise TypeError('episodes_found must be of type int') + self._episodes_found = episodes_found + + @property + def episodes_processed(self) -> int: + r""" + Number of episodes for which SetEpisodeRewards was successfully invoked. + Always 0 when dry_run is true. + """ + return self._episodes_processed + + @episodes_processed.setter + def episodes_processed(self, episodes_processed: int): + if episodes_processed is None: + del self.episodes_processed + return + if not isinstance(episodes_processed, int): + raise TypeError('episodes_processed must be of type int') + self._episodes_processed = episodes_processed + + +class CancelEpisodeRequest(KaggleObject): + r""" + Attributes: + episode_id (int) + """ + + def __init__(self): + self._episode_id = 0 + self._freeze() + + @property + def episode_id(self) -> int: + return self._episode_id + + @episode_id.setter + def episode_id(self, episode_id: int): + if episode_id is None: + del self.episode_id + return + if not isinstance(episode_id, int): + raise TypeError('episode_id must be of type int') + self._episode_id = episode_id + + +class CreateEpisodeRequest(KaggleObject): + r""" + Attributes: + submission_ids (int) + type (EpisodeType) + seed (int) + """ + + def __init__(self): + self._submission_ids = [] + self._type = EpisodeType.EPISODE_TYPE_UNSPECIFIED + self._seed = 0 + self._freeze() + + @property + def submission_ids(self) -> Optional[List[int]]: + return self._submission_ids + + @submission_ids.setter + def submission_ids(self, submission_ids: Optional[List[int]]): + if submission_ids is None: + del self.submission_ids + return + if not isinstance(submission_ids, list): + raise TypeError('submission_ids must be of type list') + if not all([isinstance(t, int) for t in submission_ids]): + raise TypeError('submission_ids must contain only items of type int') + self._submission_ids = submission_ids + + @property + def type(self) -> 'EpisodeType': + return self._type + + @type.setter + def type(self, type: 'EpisodeType'): + if type is None: + del self.type + return + if not isinstance(type, EpisodeType): + raise TypeError('type must be of type EpisodeType') + self._type = type + + @property + def seed(self) -> int: + return self._seed + + @seed.setter + def seed(self, seed: int): + if seed is None: + del self.seed + return + if not isinstance(seed, int): + raise TypeError('seed must be of type int') + self._seed = seed + + +class EpisodeTypeSummary(KaggleObject): + r""" + Attributes: + type (EpisodeType) + created_last_24h (int) + Episodes with CreateTime in the last 24h, regardless of current state. + running_count (int) + Episodes currently in EpisodeState.Created (running/queued) at any age. + completed_last_24h (int) + Episodes with State = Completed and EndTime in the last 24h. + errored_last_24h (int) + Episodes with State = Errored and EndTime in the last 24h. + """ + + def __init__(self): + self._type = EpisodeType.EPISODE_TYPE_UNSPECIFIED + self._created_last_24h = 0 + self._running_count = 0 + self._completed_last_24h = 0 + self._errored_last_24h = 0 + self._freeze() + + @property + def type(self) -> 'EpisodeType': + return self._type + + @type.setter + def type(self, type: 'EpisodeType'): + if type is None: + del self.type + return + if not isinstance(type, EpisodeType): + raise TypeError('type must be of type EpisodeType') + self._type = type + + @property + def created_last_24h(self) -> int: + """Episodes with CreateTime in the last 24h, regardless of current state.""" + return self._created_last_24h + + @created_last_24h.setter + def created_last_24h(self, created_last_24h: int): + if created_last_24h is None: + del self.created_last_24h + return + if not isinstance(created_last_24h, int): + raise TypeError('created_last_24h must be of type int') + self._created_last_24h = created_last_24h + + @property + def running_count(self) -> int: + """Episodes currently in EpisodeState.Created (running/queued) at any age.""" + return self._running_count + + @running_count.setter + def running_count(self, running_count: int): + if running_count is None: + del self.running_count + return + if not isinstance(running_count, int): + raise TypeError('running_count must be of type int') + self._running_count = running_count + + @property + def completed_last_24h(self) -> int: + """Episodes with State = Completed and EndTime in the last 24h.""" + return self._completed_last_24h + + @completed_last_24h.setter + def completed_last_24h(self, completed_last_24h: int): + if completed_last_24h is None: + del self.completed_last_24h + return + if not isinstance(completed_last_24h, int): + raise TypeError('completed_last_24h must be of type int') + self._completed_last_24h = completed_last_24h + + @property + def errored_last_24h(self) -> int: + """Episodes with State = Errored and EndTime in the last 24h.""" + return self._errored_last_24h + + @errored_last_24h.setter + def errored_last_24h(self, errored_last_24h: int): + if errored_last_24h is None: + del self.errored_last_24h + return + if not isinstance(errored_last_24h, int): + raise TypeError('errored_last_24h must be of type int') + self._errored_last_24h = errored_last_24h + + +class GenerateEpisodesForCompetitionRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + Must be provided. + num_episodes (int) + Maximum number of episodes to create. Currently we limit this to 100. + num_agents_per_episode (int) + Must be set. + dry_run (bool) + If set, we won't call BulkCreateEpisode. + """ + + def __init__(self): + self._competition_id = 0 + self._num_episodes = 0 + self._num_agents_per_episode = 0 + self._dry_run = False + self._freeze() + + @property + def competition_id(self) -> int: + """Must be provided.""" + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + @property + def num_episodes(self) -> int: + """Maximum number of episodes to create. Currently we limit this to 100.""" + return self._num_episodes + + @num_episodes.setter + def num_episodes(self, num_episodes: int): + if num_episodes is None: + del self.num_episodes + return + if not isinstance(num_episodes, int): + raise TypeError('num_episodes must be of type int') + self._num_episodes = num_episodes + + @property + def num_agents_per_episode(self) -> int: + """Must be set.""" + return self._num_agents_per_episode + + @num_agents_per_episode.setter + def num_agents_per_episode(self, num_agents_per_episode: int): + if num_agents_per_episode is None: + del self.num_agents_per_episode + return + if not isinstance(num_agents_per_episode, int): + raise TypeError('num_agents_per_episode must be of type int') + self._num_agents_per_episode = num_agents_per_episode + + @property + def dry_run(self) -> bool: + """If set, we won't call BulkCreateEpisode.""" + return self._dry_run + + @dry_run.setter + def dry_run(self, dry_run: bool): + if dry_run is None: + del self.dry_run + return + if not isinstance(dry_run, bool): + raise TypeError('dry_run must be of type bool') + self._dry_run = dry_run + + +class GenerateEpisodesForCompetitionResponse(KaggleObject): + r""" + Attributes: + bulk_create_episode_request (BulkCreateEpisodeRequest) + The BulkCreateEpisodeRequest we generated. + bulk_create_episode_response (BulkCreateEpisodeResponse) + The response from calling BulkCreateEpisode, if dry_run was false. + """ + + def __init__(self): + self._bulk_create_episode_request = None + self._bulk_create_episode_response = None + self._freeze() + + @property + def bulk_create_episode_request(self) -> Optional['BulkCreateEpisodeRequest']: + """The BulkCreateEpisodeRequest we generated.""" + return self._bulk_create_episode_request + + @bulk_create_episode_request.setter + def bulk_create_episode_request(self, bulk_create_episode_request: Optional['BulkCreateEpisodeRequest']): + if bulk_create_episode_request is None: + del self.bulk_create_episode_request + return + if not isinstance(bulk_create_episode_request, BulkCreateEpisodeRequest): + raise TypeError('bulk_create_episode_request must be of type BulkCreateEpisodeRequest') + self._bulk_create_episode_request = bulk_create_episode_request + + @property + def bulk_create_episode_response(self) -> Optional['BulkCreateEpisodeResponse']: + """The response from calling BulkCreateEpisode, if dry_run was false.""" + return self._bulk_create_episode_response + + @bulk_create_episode_response.setter + def bulk_create_episode_response(self, bulk_create_episode_response: Optional['BulkCreateEpisodeResponse']): + if bulk_create_episode_response is None: + del self.bulk_create_episode_response + return + if not isinstance(bulk_create_episode_response, BulkCreateEpisodeResponse): + raise TypeError('bulk_create_episode_response must be of type BulkCreateEpisodeResponse') + self._bulk_create_episode_response = bulk_create_episode_response + + +class GetEpisodeRequest(KaggleObject): + r""" + Attributes: + episode_id (int) + """ + + def __init__(self): + self._episode_id = 0 + self._freeze() + + @property + def episode_id(self) -> int: + return self._episode_id + + @episode_id.setter + def episode_id(self, episode_id: int): + if episode_id is None: + del self.episode_id + return + if not isinstance(episode_id, int): + raise TypeError('episode_id must be of type int') + self._episode_id = episode_id + + +class GetEpisodeResponse(KaggleObject): + r""" + Attributes: + episode (Episode) + teams (Team) + """ + + def __init__(self): + self._episode = None + self._teams = [] + self._freeze() + + @property + def episode(self) -> Optional['Episode']: + return self._episode + + @episode.setter + def episode(self, episode: Optional['Episode']): + if episode is None: + del self.episode + return + if not isinstance(episode, Episode): + raise TypeError('episode must be of type Episode') + self._episode = episode + + @property + def teams(self) -> Optional[List[Optional['Team']]]: + return self._teams + + @teams.setter + def teams(self, teams: Optional[List[Optional['Team']]]): + if teams is None: + del self.teams + return + if not isinstance(teams, list): + raise TypeError('teams must be of type list') + if not all([isinstance(t, Team) for t in teams]): + raise TypeError('teams must contain only items of type Team') + self._teams = teams + + +class GetEpisodeSummaryRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + """ + + def __init__(self): + self._competition_id = 0 + self._freeze() + + @property + def competition_id(self) -> int: + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + +class GetEpisodeSummaryResponse(KaggleObject): + r""" + Attributes: + type_summaries (EpisodeTypeSummary) + One entry per EpisodeType with activity in the last 24h or currently + running. Types with no recent or running episodes are omitted, so a + never-used type will not appear at all. (A map would + be nicer but proto3 disallows enum-typed map keys.) + team_episode_counts (TeamEpisodeCount) + """ + + def __init__(self): + self._type_summaries = [] + self._team_episode_counts = [] + self._freeze() + + @property + def type_summaries(self) -> Optional[List[Optional['EpisodeTypeSummary']]]: + r""" + One entry per EpisodeType with activity in the last 24h or currently + running. Types with no recent or running episodes are omitted, so a + never-used type will not appear at all. (A map would + be nicer but proto3 disallows enum-typed map keys.) + """ + return self._type_summaries + + @type_summaries.setter + def type_summaries(self, type_summaries: Optional[List[Optional['EpisodeTypeSummary']]]): + if type_summaries is None: + del self.type_summaries + return + if not isinstance(type_summaries, list): + raise TypeError('type_summaries must be of type list') + if not all([isinstance(t, EpisodeTypeSummary) for t in type_summaries]): + raise TypeError('type_summaries must contain only items of type EpisodeTypeSummary') + self._type_summaries = type_summaries + + @property + def team_episode_counts(self) -> Optional[List[Optional['TeamEpisodeCount']]]: + return self._team_episode_counts + + @team_episode_counts.setter + def team_episode_counts(self, team_episode_counts: Optional[List[Optional['TeamEpisodeCount']]]): + if team_episode_counts is None: + del self.team_episode_counts + return + if not isinstance(team_episode_counts, list): + raise TypeError('team_episode_counts must be of type list') + if not all([isinstance(t, TeamEpisodeCount) for t in team_episode_counts]): + raise TypeError('team_episode_counts must contain only items of type TeamEpisodeCount') + self._team_episode_counts = team_episode_counts + + +class ListEpisodesFromCompetitionFilters(KaggleObject): + r""" + Attributes: + state (EpisodeState) + type (EpisodeType) + team_ids (int) + episode_ids (int) + """ + + def __init__(self): + self._state = None + self._type = None + self._team_ids = [] + self._episode_ids = [] + self._freeze() + + @property + def state(self) -> 'EpisodeState': + return self._state or EpisodeState.EPISODE_STATE_UNSPECIFIED + + @state.setter + def state(self, state: Optional['EpisodeState']): + if state is None: + del self.state + return + if not isinstance(state, EpisodeState): + raise TypeError('state must be of type EpisodeState') + self._state = state + + @property + def type(self) -> 'EpisodeType': + return self._type or EpisodeType.EPISODE_TYPE_UNSPECIFIED + + @type.setter + def type(self, type: Optional['EpisodeType']): + if type is None: + del self.type + return + if not isinstance(type, EpisodeType): + raise TypeError('type must be of type EpisodeType') + self._type = type + + @property + def team_ids(self) -> Optional[List[int]]: + return self._team_ids + + @team_ids.setter + def team_ids(self, team_ids: Optional[List[int]]): + if team_ids is None: + del self.team_ids + return + if not isinstance(team_ids, list): + raise TypeError('team_ids must be of type list') + if not all([isinstance(t, int) for t in team_ids]): + raise TypeError('team_ids must contain only items of type int') + self._team_ids = team_ids + + @property + def episode_ids(self) -> Optional[List[int]]: + return self._episode_ids + + @episode_ids.setter + def episode_ids(self, episode_ids: Optional[List[int]]): + if episode_ids is None: + del self.episode_ids + return + if not isinstance(episode_ids, list): + raise TypeError('episode_ids must be of type list') + if not all([isinstance(t, int) for t in episode_ids]): + raise TypeError('episode_ids must contain only items of type int') + self._episode_ids = episode_ids + + +class ListEpisodesFromCompetitionRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + page_size (int) + page_token (str) + skip (int) + filters (ListEpisodesFromCompetitionFilters) + Optional list episodes filters: + episode type, episode state. + """ + + def __init__(self): + self._competition_id = 0 + self._page_size = 0 + self._page_token = "" + self._skip = 0 + self._filters = None + self._freeze() + + @property + def competition_id(self) -> int: + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + @property + def page_size(self) -> int: + return self._page_size + + @page_size.setter + def page_size(self, page_size: int): + if page_size is None: + del self.page_size + return + if not isinstance(page_size, int): + raise TypeError('page_size must be of type int') + self._page_size = page_size + + @property + def page_token(self) -> str: + return self._page_token + + @page_token.setter + def page_token(self, page_token: str): + if page_token is None: + del self.page_token + return + if not isinstance(page_token, str): + raise TypeError('page_token must be of type str') + self._page_token = page_token + + @property + def skip(self) -> int: + return self._skip + + @skip.setter + def skip(self, skip: int): + if skip is None: + del self.skip + return + if not isinstance(skip, int): + raise TypeError('skip must be of type int') + self._skip = skip + + @property + def filters(self) -> Optional['ListEpisodesFromCompetitionFilters']: + r""" + Optional list episodes filters: + episode type, episode state. + """ + return self._filters + + @filters.setter + def filters(self, filters: Optional['ListEpisodesFromCompetitionFilters']): + if filters is None: + del self.filters + return + if not isinstance(filters, ListEpisodesFromCompetitionFilters): + raise TypeError('filters must be of type ListEpisodesFromCompetitionFilters') + self._filters = filters + + +class ListEpisodesFromCompetitionResponse(KaggleObject): + r""" + Attributes: + episodes (Episode) + total_episodes (int) + total_pages (int) + next_page_token (str) + average_episode_duration_ms (float) + Average duration (in ms) of completed episodes for this competition. + Used by the frontend to estimate remaining time for active episodes. + completed_episode_count (int) + Number of completed episodes used to compute the average duration. + The frontend uses this to require a minimum sample size before showing + estimates. + """ + + def __init__(self): + self._episodes = [] + self._total_episodes = 0 + self._total_pages = 0 + self._next_page_token = None + self._average_episode_duration_ms = None + self._completed_episode_count = None + self._freeze() + + @property + def episodes(self) -> Optional[List[Optional['Episode']]]: + return self._episodes + + @episodes.setter + def episodes(self, episodes: Optional[List[Optional['Episode']]]): + if episodes is None: + del self.episodes + return + if not isinstance(episodes, list): + raise TypeError('episodes must be of type list') + if not all([isinstance(t, Episode) for t in episodes]): + raise TypeError('episodes must contain only items of type Episode') + self._episodes = episodes + + @property + def total_episodes(self) -> int: + return self._total_episodes + + @total_episodes.setter + def total_episodes(self, total_episodes: int): + if total_episodes is None: + del self.total_episodes + return + if not isinstance(total_episodes, int): + raise TypeError('total_episodes must be of type int') + self._total_episodes = total_episodes + + @property + def total_pages(self) -> int: + return self._total_pages + + @total_pages.setter + def total_pages(self, total_pages: int): + if total_pages is None: + del self.total_pages + return + if not isinstance(total_pages, int): + raise TypeError('total_pages must be of type int') + self._total_pages = total_pages + + @property + def next_page_token(self) -> str: + return self._next_page_token or "" + + @next_page_token.setter + def next_page_token(self, next_page_token: Optional[str]): + if next_page_token is None: + del self.next_page_token + return + if not isinstance(next_page_token, str): + raise TypeError('next_page_token must be of type str') + self._next_page_token = next_page_token + + @property + def average_episode_duration_ms(self) -> float: + r""" + Average duration (in ms) of completed episodes for this competition. + Used by the frontend to estimate remaining time for active episodes. + """ + return self._average_episode_duration_ms or 0.0 + + @average_episode_duration_ms.setter + def average_episode_duration_ms(self, average_episode_duration_ms: Optional[float]): + if average_episode_duration_ms is None: + del self.average_episode_duration_ms + return + if not isinstance(average_episode_duration_ms, float): + raise TypeError('average_episode_duration_ms must be of type float') + self._average_episode_duration_ms = average_episode_duration_ms + + @property + def completed_episode_count(self) -> int: + r""" + Number of completed episodes used to compute the average duration. + The frontend uses this to require a minimum sample size before showing + estimates. + """ + return self._completed_episode_count or 0 + + @completed_episode_count.setter + def completed_episode_count(self, completed_episode_count: Optional[int]): + if completed_episode_count is None: + del self.completed_episode_count + return + if not isinstance(completed_episode_count, int): + raise TypeError('completed_episode_count must be of type int') + self._completed_episode_count = completed_episode_count + + +class ListEpisodesRequest(KaggleObject): + r""" + Only the first populated ID filter will be used. Exception thrown if none + are populated. + + Attributes: + ids (int) + submission_id (int) + benchmark_task_version_filter (BenchmarkTaskVersionFilter) + successful_only (bool) + include_in_progress (bool) + When true, episodes still in CREATED state (queued / in-progress) are + returned alongside completed episodes. Intended for the submission owner's + own view so they can see which games their submission is currently playing. + """ + + def __init__(self): + self._ids = [] + self._submission_id = None + self._benchmark_task_version_filter = None + self._successful_only = None + self._include_in_progress = None + self._freeze() + + @property + def ids(self) -> Optional[List[int]]: + return self._ids + + @ids.setter + def ids(self, ids: Optional[List[int]]): + if ids is None: + del self.ids + return + if not isinstance(ids, list): + raise TypeError('ids must be of type list') + if not all([isinstance(t, int) for t in ids]): + raise TypeError('ids must contain only items of type int') + self._ids = ids + + @property + def submission_id(self) -> int: + return self._submission_id or 0 + + @submission_id.setter + def submission_id(self, submission_id: Optional[int]): + if submission_id is None: + del self.submission_id + return + if not isinstance(submission_id, int): + raise TypeError('submission_id must be of type int') + self._submission_id = submission_id + + @property + def benchmark_task_version_filter(self) -> Optional['BenchmarkTaskVersionFilter']: + return self._benchmark_task_version_filter or None + + @benchmark_task_version_filter.setter + def benchmark_task_version_filter(self, benchmark_task_version_filter: Optional[Optional['BenchmarkTaskVersionFilter']]): + if benchmark_task_version_filter is None: + del self.benchmark_task_version_filter + return + if not isinstance(benchmark_task_version_filter, BenchmarkTaskVersionFilter): + raise TypeError('benchmark_task_version_filter must be of type BenchmarkTaskVersionFilter') + self._benchmark_task_version_filter = benchmark_task_version_filter + + @property + def successful_only(self) -> bool: + return self._successful_only or False + + @successful_only.setter + def successful_only(self, successful_only: Optional[bool]): + if successful_only is None: + del self.successful_only + return + if not isinstance(successful_only, bool): + raise TypeError('successful_only must be of type bool') + self._successful_only = successful_only + + @property + def include_in_progress(self) -> bool: + r""" + When true, episodes still in CREATED state (queued / in-progress) are + returned alongside completed episodes. Intended for the submission owner's + own view so they can see which games their submission is currently playing. + """ + return self._include_in_progress or False + + @include_in_progress.setter + def include_in_progress(self, include_in_progress: Optional[bool]): + if include_in_progress is None: + del self.include_in_progress + return + if not isinstance(include_in_progress, bool): + raise TypeError('include_in_progress must be of type bool') + self._include_in_progress = include_in_progress + + +class ListEpisodesResponse(KaggleObject): + r""" + Attributes: + episodes (Episode) + EpisodeAgents refs populated, each with no refs, instead pulled out below. + submissions (Submission) + Distinct Submissions that would've been used for EpisodeAgent.Submission + in above. No refs. + teams (Team) + Distinct Teams that would've been used for Submission.Team above. No refs. + """ + + def __init__(self): + self._episodes = [] + self._submissions = [] + self._teams = [] + self._freeze() + + @property + def episodes(self) -> Optional[List[Optional['Episode']]]: + """EpisodeAgents refs populated, each with no refs, instead pulled out below.""" + return self._episodes + + @episodes.setter + def episodes(self, episodes: Optional[List[Optional['Episode']]]): + if episodes is None: + del self.episodes + return + if not isinstance(episodes, list): + raise TypeError('episodes must be of type list') + if not all([isinstance(t, Episode) for t in episodes]): + raise TypeError('episodes must contain only items of type Episode') + self._episodes = episodes + + @property + def submissions(self) -> Optional[List[Optional['Submission']]]: + r""" + Distinct Submissions that would've been used for EpisodeAgent.Submission + in above. No refs. + """ + return self._submissions + + @submissions.setter + def submissions(self, submissions: Optional[List[Optional['Submission']]]): + if submissions is None: + del self.submissions + return + if not isinstance(submissions, list): + raise TypeError('submissions must be of type list') + if not all([isinstance(t, Submission) for t in submissions]): + raise TypeError('submissions must contain only items of type Submission') + self._submissions = submissions + + @property + def teams(self) -> Optional[List[Optional['Team']]]: + """Distinct Teams that would've been used for Submission.Team above. No refs.""" + return self._teams + + @teams.setter + def teams(self, teams: Optional[List[Optional['Team']]]): + if teams is None: + del self.teams + return + if not isinstance(teams, list): + raise TypeError('teams must be of type list') + if not all([isinstance(t, Team) for t in teams]): + raise TypeError('teams must contain only items of type Team') + self._teams = teams + + +class ListValidationEpisodesRequest(KaggleObject): + r""" + Attributes: + submission_ids (int) + """ + + def __init__(self): + self._submission_ids = [] + self._freeze() + + @property + def submission_ids(self) -> Optional[List[int]]: + return self._submission_ids + + @submission_ids.setter + def submission_ids(self, submission_ids: Optional[List[int]]): + if submission_ids is None: + del self.submission_ids + return + if not isinstance(submission_ids, list): + raise TypeError('submission_ids must be of type list') + if not all([isinstance(t, int) for t in submission_ids]): + raise TypeError('submission_ids must contain only items of type int') + self._submission_ids = submission_ids + + +class ListValidationEpisodesResponse(KaggleObject): + r""" + Attributes: + submission_validation_episode_map (int) + """ + + def __init__(self): + self._submission_validation_episode_map = {} + self._freeze() + + @property + def submission_validation_episode_map(self) -> Optional[Dict[int, int]]: + return self._submission_validation_episode_map + + @submission_validation_episode_map.setter + def submission_validation_episode_map(self, submission_validation_episode_map: Optional[Dict[int, int]]): + if submission_validation_episode_map is None: + del self.submission_validation_episode_map + return + if not isinstance(submission_validation_episode_map, dict): + raise TypeError('submission_validation_episode_map must be of type dict') + if not all([isinstance(v, int) for k, v in submission_validation_episode_map]): + raise TypeError('submission_validation_episode_map must contain only items of type int') + self._submission_validation_episode_map = submission_validation_episode_map + + +class MarkEnvironmentSubmissionValidatedRequest(KaggleObject): + r""" + Attributes: + submission_id (int) + """ + + def __init__(self): + self._submission_id = 0 + self._freeze() + + @property + def submission_id(self) -> int: + return self._submission_id + + @submission_id.setter + def submission_id(self, submission_id: int): + if submission_id is None: + del self.submission_id + return + if not isinstance(submission_id, int): + raise TypeError('submission_id must be of type int') + self._submission_id = submission_id + + +class SetEpisodeErroredRequest(KaggleObject): + r""" + This sets Episode.State = EpisodeState.ERRORED + + Attributes: + episode_id (int) + """ + + def __init__(self): + self._episode_id = 0 + self._freeze() + + @property + def episode_id(self) -> int: + return self._episode_id + + @episode_id.setter + def episode_id(self, episode_id: int): + if episode_id is None: + del self.episode_id + return + if not isinstance(episode_id, int): + raise TypeError('episode_id must be of type int') + self._episode_id = episode_id + + +class TeamEpisodeCount(KaggleObject): + r""" + Attributes: + team_id (int) + episode_state (EpisodeState) + episode_count (int) + team_name (str) + """ + + def __init__(self): + self._team_id = 0 + self._episode_state = EpisodeState.EPISODE_STATE_UNSPECIFIED + self._episode_count = 0 + self._team_name = "" + self._freeze() + + @property + def team_id(self) -> int: + return self._team_id + + @team_id.setter + def team_id(self, team_id: int): + if team_id is None: + del self.team_id + return + if not isinstance(team_id, int): + raise TypeError('team_id must be of type int') + self._team_id = team_id + + @property + def episode_state(self) -> 'EpisodeState': + return self._episode_state + + @episode_state.setter + def episode_state(self, episode_state: 'EpisodeState'): + if episode_state is None: + del self.episode_state + return + if not isinstance(episode_state, EpisodeState): + raise TypeError('episode_state must be of type EpisodeState') + self._episode_state = episode_state + + @property + def episode_count(self) -> int: + return self._episode_count + + @episode_count.setter + def episode_count(self, episode_count: int): + if episode_count is None: + del self.episode_count + return + if not isinstance(episode_count, int): + raise TypeError('episode_count must be of type int') + self._episode_count = episode_count + + @property + def team_name(self) -> str: + return self._team_name + + @team_name.setter + def team_name(self, team_name: str): + if team_name is None: + del self.team_name + return + if not isinstance(team_name, str): + raise TypeError('team_name must be of type str') + self._team_name = team_name + + +BenchmarkTaskVersionFilter._fields = [ + FieldMetadata("benchmarkTaskVersionId", "benchmark_task_version_id", "_benchmark_task_version_id", int, 0, PredefinedSerializer()), + FieldMetadata("benchmarkModelVersionId", "benchmark_model_version_id", "_benchmark_model_version_id", int, 0, PredefinedSerializer()), +] + +BulkCancelEpisodesRequest._fields = [ + FieldMetadata("episodeIds", "episode_ids", "_episode_ids", int, [], ListSerializer(PredefinedSerializer())), +] + +BulkCreateEpisodeRequest._fields = [ + FieldMetadata("requests", "requests", "_requests", CreateEpisodeRequest, [], ListSerializer(KaggleObjectSerializer())), +] + +BulkCreateEpisodeResponse._fields = [ + FieldMetadata("episodes", "episodes", "_episodes", Episode, [], ListSerializer(KaggleObjectSerializer())), +] + +BulkSetEpisodeRewardsRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), + FieldMetadata("episodeState", "episode_state", "_episode_state", EpisodeState, EpisodeState.EPISODE_STATE_UNSPECIFIED, EnumSerializer()), + FieldMetadata("dryRun", "dry_run", "_dry_run", bool, False, PredefinedSerializer()), + FieldMetadata("minAgeHours", "min_age_hours", "_min_age_hours", int, 0, PredefinedSerializer()), + FieldMetadata("maxEpisodes", "max_episodes", "_max_episodes", int, 0, PredefinedSerializer()), +] + +BulkSetEpisodeRewardsResponse._fields = [ + FieldMetadata("episodesFound", "episodes_found", "_episodes_found", int, 0, PredefinedSerializer()), + FieldMetadata("episodesProcessed", "episodes_processed", "_episodes_processed", int, 0, PredefinedSerializer()), +] + +CancelEpisodeRequest._fields = [ + FieldMetadata("episodeId", "episode_id", "_episode_id", int, 0, PredefinedSerializer()), +] + +CreateEpisodeRequest._fields = [ + FieldMetadata("submissionIds", "submission_ids", "_submission_ids", int, [], ListSerializer(PredefinedSerializer())), + FieldMetadata("type", "type", "_type", EpisodeType, EpisodeType.EPISODE_TYPE_UNSPECIFIED, EnumSerializer()), + FieldMetadata("seed", "seed", "_seed", int, 0, PredefinedSerializer()), +] + +EpisodeTypeSummary._fields = [ + FieldMetadata("type", "type", "_type", EpisodeType, EpisodeType.EPISODE_TYPE_UNSPECIFIED, EnumSerializer()), + FieldMetadata("createdLast24h", "created_last_24h", "_created_last_24h", int, 0, PredefinedSerializer()), + FieldMetadata("runningCount", "running_count", "_running_count", int, 0, PredefinedSerializer()), + FieldMetadata("completedLast24h", "completed_last_24h", "_completed_last_24h", int, 0, PredefinedSerializer()), + FieldMetadata("erroredLast24h", "errored_last_24h", "_errored_last_24h", int, 0, PredefinedSerializer()), +] + +GenerateEpisodesForCompetitionRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), + FieldMetadata("numEpisodes", "num_episodes", "_num_episodes", int, 0, PredefinedSerializer()), + FieldMetadata("numAgentsPerEpisode", "num_agents_per_episode", "_num_agents_per_episode", int, 0, PredefinedSerializer()), + FieldMetadata("dryRun", "dry_run", "_dry_run", bool, False, PredefinedSerializer()), +] + +GenerateEpisodesForCompetitionResponse._fields = [ + FieldMetadata("bulkCreateEpisodeRequest", "bulk_create_episode_request", "_bulk_create_episode_request", BulkCreateEpisodeRequest, None, KaggleObjectSerializer()), + FieldMetadata("bulkCreateEpisodeResponse", "bulk_create_episode_response", "_bulk_create_episode_response", BulkCreateEpisodeResponse, None, KaggleObjectSerializer()), +] + +GetEpisodeRequest._fields = [ + FieldMetadata("episodeId", "episode_id", "_episode_id", int, 0, PredefinedSerializer()), +] + +GetEpisodeResponse._fields = [ + FieldMetadata("episode", "episode", "_episode", Episode, None, KaggleObjectSerializer()), + FieldMetadata("teams", "teams", "_teams", Team, [], ListSerializer(KaggleObjectSerializer())), +] + +GetEpisodeSummaryRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), +] + +GetEpisodeSummaryResponse._fields = [ + FieldMetadata("typeSummaries", "type_summaries", "_type_summaries", EpisodeTypeSummary, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("teamEpisodeCounts", "team_episode_counts", "_team_episode_counts", TeamEpisodeCount, [], ListSerializer(KaggleObjectSerializer())), +] + +ListEpisodesFromCompetitionFilters._fields = [ + FieldMetadata("state", "state", "_state", EpisodeState, None, EnumSerializer(), optional=True), + FieldMetadata("type", "type", "_type", EpisodeType, None, EnumSerializer(), optional=True), + FieldMetadata("teamIds", "team_ids", "_team_ids", int, [], ListSerializer(PredefinedSerializer())), + FieldMetadata("episodeIds", "episode_ids", "_episode_ids", int, [], ListSerializer(PredefinedSerializer())), +] + +ListEpisodesFromCompetitionRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), + FieldMetadata("pageSize", "page_size", "_page_size", int, 0, PredefinedSerializer()), + FieldMetadata("pageToken", "page_token", "_page_token", str, "", PredefinedSerializer()), + FieldMetadata("skip", "skip", "_skip", int, 0, PredefinedSerializer()), + FieldMetadata("filters", "filters", "_filters", ListEpisodesFromCompetitionFilters, None, KaggleObjectSerializer()), +] + +ListEpisodesFromCompetitionResponse._fields = [ + FieldMetadata("episodes", "episodes", "_episodes", Episode, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("totalEpisodes", "total_episodes", "_total_episodes", int, 0, PredefinedSerializer()), + FieldMetadata("totalPages", "total_pages", "_total_pages", int, 0, PredefinedSerializer()), + FieldMetadata("nextPageToken", "next_page_token", "_next_page_token", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("averageEpisodeDurationMs", "average_episode_duration_ms", "_average_episode_duration_ms", float, None, PredefinedSerializer(), optional=True), + FieldMetadata("completedEpisodeCount", "completed_episode_count", "_completed_episode_count", int, None, PredefinedSerializer(), optional=True), +] + +ListEpisodesRequest._fields = [ + FieldMetadata("ids", "ids", "_ids", int, [], ListSerializer(PredefinedSerializer())), + FieldMetadata("submissionId", "submission_id", "_submission_id", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("benchmarkTaskVersionFilter", "benchmark_task_version_filter", "_benchmark_task_version_filter", BenchmarkTaskVersionFilter, None, KaggleObjectSerializer(), optional=True), + FieldMetadata("successfulOnly", "successful_only", "_successful_only", bool, None, PredefinedSerializer(), optional=True), + FieldMetadata("includeInProgress", "include_in_progress", "_include_in_progress", bool, None, PredefinedSerializer(), optional=True), +] + +ListEpisodesResponse._fields = [ + FieldMetadata("episodes", "episodes", "_episodes", Episode, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("submissions", "submissions", "_submissions", Submission, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("teams", "teams", "_teams", Team, [], ListSerializer(KaggleObjectSerializer())), +] + +ListValidationEpisodesRequest._fields = [ + FieldMetadata("submissionIds", "submission_ids", "_submission_ids", int, [], ListSerializer(PredefinedSerializer())), +] + +ListValidationEpisodesResponse._fields = [ + FieldMetadata("submissionValidationEpisodeMap", "submission_validation_episode_map", "_submission_validation_episode_map", int, {}, MapSerializer(PredefinedSerializer())), +] + +MarkEnvironmentSubmissionValidatedRequest._fields = [ + FieldMetadata("submissionId", "submission_id", "_submission_id", int, 0, PredefinedSerializer()), +] + +SetEpisodeErroredRequest._fields = [ + FieldMetadata("episodeId", "episode_id", "_episode_id", int, 0, PredefinedSerializer()), +] + +TeamEpisodeCount._fields = [ + FieldMetadata("teamId", "team_id", "_team_id", int, 0, PredefinedSerializer()), + FieldMetadata("episodeState", "episode_state", "_episode_state", EpisodeState, EpisodeState.EPISODE_STATE_UNSPECIFIED, EnumSerializer()), + FieldMetadata("episodeCount", "episode_count", "_episode_count", int, 0, PredefinedSerializer()), + FieldMetadata("teamName", "team_name", "_team_name", str, "", PredefinedSerializer()), +] + diff --git a/kagglesdk/competitions/types/host_service.py b/kagglesdk/competitions/types/host_service.py new file mode 100644 index 0000000..c40af10 --- /dev/null +++ b/kagglesdk/competitions/types/host_service.py @@ -0,0 +1,2485 @@ +from datetime import datetime +from google.protobuf.field_mask_pb2 import FieldMask +from kagglesdk.common.types.cropped_image_upload import CroppedImageUpload +from kagglesdk.competitions.legacy.types.legacy_competition_host_service import EvaluationMetricParameter +from kagglesdk.competitions.types.competition import Competition, PubliclyCloneable, Reward +from kagglesdk.competitions.types.competition_email_invite import CompetitionEmailInvite +from kagglesdk.competitions.types.competition_enums import CompetitionPrivacy, HostSegment +from kagglesdk.competitions.types.evaluation_algorithm import CompetitionMetricVersion, EvaluationAlgorithm +from kagglesdk.competitions.types.simulations import CompetitionSimulationSettings +from kagglesdk.kaggle_object import * +from kagglesdk.kernels.types.kernels_service import GithubFileInfo +from kagglesdk.licenses.types.licenses_types import LicenseOption +from kagglesdk.users.types.user_avatar import UserAvatar +from typing import Optional, List, Dict + +class AddHostUserRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + host_user_id (int) + """ + + def __init__(self): + self._competition_id = 0 + self._host_user_id = 0 + self._freeze() + + @property + def competition_id(self) -> int: + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + @property + def host_user_id(self) -> int: + return self._host_user_id + + @host_user_id.setter + def host_user_id(self, host_user_id: int): + if host_user_id is None: + del self.host_user_id + return + if not isinstance(host_user_id, int): + raise TypeError('host_user_id must be of type int') + self._host_user_id = host_user_id + + +class ClaimCompetitionSyntheticCopyRequest(KaggleObject): + r""" + Attributes: + base_competition_id (int) + title (str) + slug (str) + brief_description (str) + privacy (CompetitionPrivacy) + disable_kernels (bool) + restrict_link_to_email_list (bool) + restricts those who join the competition via share link to a specific list + of emails/domains + reward (Reward) + host_segment (HostSegment) + """ + + def __init__(self): + self._base_competition_id = 0 + self._title = "" + self._slug = "" + self._brief_description = "" + self._privacy = CompetitionPrivacy.COMPETITION_PRIVACY_UNSPECIFIED + self._disable_kernels = None + self._restrict_link_to_email_list = None + self._reward = None + self._host_segment = None + self._freeze() + + @property + def base_competition_id(self) -> int: + return self._base_competition_id + + @base_competition_id.setter + def base_competition_id(self, base_competition_id: int): + if base_competition_id is None: + del self.base_competition_id + return + if not isinstance(base_competition_id, int): + raise TypeError('base_competition_id must be of type int') + self._base_competition_id = base_competition_id + + @property + def title(self) -> str: + return self._title + + @title.setter + def title(self, title: str): + if title is None: + del self.title + return + if not isinstance(title, str): + raise TypeError('title must be of type str') + self._title = title + + @property + def slug(self) -> str: + return self._slug + + @slug.setter + def slug(self, slug: str): + if slug is None: + del self.slug + return + if not isinstance(slug, str): + raise TypeError('slug must be of type str') + self._slug = slug + + @property + def brief_description(self) -> str: + return self._brief_description + + @brief_description.setter + def brief_description(self, brief_description: str): + if brief_description is None: + del self.brief_description + return + if not isinstance(brief_description, str): + raise TypeError('brief_description must be of type str') + self._brief_description = brief_description + + @property + def privacy(self) -> 'CompetitionPrivacy': + return self._privacy + + @privacy.setter + def privacy(self, privacy: 'CompetitionPrivacy'): + if privacy is None: + del self.privacy + return + if not isinstance(privacy, CompetitionPrivacy): + raise TypeError('privacy must be of type CompetitionPrivacy') + self._privacy = privacy + + @property + def disable_kernels(self) -> bool: + return self._disable_kernels or False + + @disable_kernels.setter + def disable_kernels(self, disable_kernels: Optional[bool]): + if disable_kernels is None: + del self.disable_kernels + return + if not isinstance(disable_kernels, bool): + raise TypeError('disable_kernels must be of type bool') + self._disable_kernels = disable_kernels + + @property + def restrict_link_to_email_list(self) -> bool: + r""" + restricts those who join the competition via share link to a specific list + of emails/domains + """ + return self._restrict_link_to_email_list or False + + @restrict_link_to_email_list.setter + def restrict_link_to_email_list(self, restrict_link_to_email_list: Optional[bool]): + if restrict_link_to_email_list is None: + del self.restrict_link_to_email_list + return + if not isinstance(restrict_link_to_email_list, bool): + raise TypeError('restrict_link_to_email_list must be of type bool') + self._restrict_link_to_email_list = restrict_link_to_email_list + + @property + def reward(self) -> Optional['Reward']: + return self._reward or None + + @reward.setter + def reward(self, reward: Optional[Optional['Reward']]): + if reward is None: + del self.reward + return + if not isinstance(reward, Reward): + raise TypeError('reward must be of type Reward') + self._reward = reward + + @property + def host_segment(self) -> 'HostSegment': + return self._host_segment or HostSegment.HOST_SEGMENT_UNSPECIFIED + + @host_segment.setter + def host_segment(self, host_segment: Optional['HostSegment']): + if host_segment is None: + del self.host_segment + return + if not isinstance(host_segment, HostSegment): + raise TypeError('host_segment must be of type HostSegment') + self._host_segment = host_segment + + +class ClaimCompetitionSyntheticCopyResponse(KaggleObject): + r""" + Attributes: + claimed_competition_id (int) + """ + + def __init__(self): + self._claimed_competition_id = 0 + self._freeze() + + @property + def claimed_competition_id(self) -> int: + return self._claimed_competition_id + + @claimed_competition_id.setter + def claimed_competition_id(self, claimed_competition_id: int): + if claimed_competition_id is None: + del self.claimed_competition_id + return + if not isinstance(claimed_competition_id, int): + raise TypeError('claimed_competition_id must be of type int') + self._claimed_competition_id = claimed_competition_id + + +class CompetitionSettings(KaggleObject): + r""" + Unified competition settings. See go/unified-competition-settings + Field names match the Competition message when possible. Note this is + not 1-1 with the Competition message because the Competition message: + - does not contain all Competition settings + - contains fields that will never be updateable + - may not have a structure that's conducive to certain update operations + For example, adding/removing entries from long repeated fields. + + Attributes: + title (str) + GENERAL SETTINGS GROUP (field numbers 1-19) + brief_description (str) + 'Subtitle' in the UI. + competition_name (str) + 'URL' in the UI. + host_segment (HostSegment) + GENERAL SETTINGS GROUP: ADMIN ONLY + 'Category' in the UI. + organization_id (int) + 'Creating As' in the UI. + rules_required (bool) + 'Require Rules Agreement' in the UI. + publicly_cloneable (PubliclyCloneable) + Indicates if a competition is marked for anyone to clone. + has_scripts (bool) + 'Enable Notebooks' in the UI. + requires_identity_verification (bool) + ACCESS & TEAMS SETTINGS GROUP: ADMIN ONLY + Whether identity verification with Persona is required to submit an entry + to the competition. + enable_team_files (bool) + 'Enable Team File Drop' in the UI. + team_file_deadline (datetime) + TODO(aip.dev/142): (-- api-linter: core::0142::time-field-names=disabled + --) + Should only be set if enable_team_files is true. + Team File Drop Deadline' in the UI. + team_merger_explicit_deadline (datetime) + KEY DATES SETTINGS GROUP: ADMIN ONLY + 'Team Merger Deadline' in the UI. + TODO(aip.dev/142): (-- api-linter: core::0142::time-field-names=disabled + --) + prohibit_new_entrants_explicit_deadline (datetime) + 'New Entrants Deadline' in the UI. + TODO(b/409380918): prohibit_new_entrants may affect value of + TODO(aip.dev/142): (-- api-linter: core::0142::time-field-names=disabled + --) + kernels_publishing_disabled_deadline (datetime) + Whether publishing of Kernels associated with this competition is currently + disabled (derived from checking DisableKernelsPublishing and + KernelsPublishingDeadline). + Should only be set if has_scripts is true. + 'Disable Public Notebooks Until' in the UI. + disable_submissions (bool) + public_leaderboard_disclaimer_message (str) + has_leaderboard (bool) + SUBMISSIONS & LEADERBOARD SETTINGS GROUP: ADMIN ONLY + 'Show Leaderboard' in the UI. + disable_leaderboard_prize_indicator (bool) + 'Show Leaderboard Prize Indicator' in the UI. + withold_final_leaderboard_until_it_has_been_verified (bool) + 'Hold Final Leaderboard for Verification' in the UI. + final_leaderboard_has_been_verified (bool) + Should only be set if withold_final_leaderboard_until_it_has_been_verified + is true. + 'Final Leaderboard Verified' in the UI. + final_leaderboard_disclaimer_message (str) + 'Private Leaderboard Disclaimer' in the UI. + only_allow_kernel_submissions (bool) + CODE COMPETITION SETTINGS GROUP (field numbers 100-119) + 'Code Competition' in the UI. Whether competitors must submit a Notebook. + uses_synchronous_reruns (bool) + 'Uses Synchronous Reruns' in the UI. + max_cpu_runtime_minutes (int) + 'Max CPU Runtime Minutes' in the UI. + max_gpu_runtime_minutes (int) + 'Max GPU Runtime Minutes' in the UI. + rerun_override_kernel_id (int) + Host-authored template Notebook the frontend wraps the user's artifact + (e.g. skill.md) into before submitting. Parallels + main_py_override_kernel_id. + """ + + def __init__(self): + self._title = "" + self._brief_description = "" + self._competition_name = "" + self._host_segment = HostSegment.HOST_SEGMENT_UNSPECIFIED + self._organization_id = 0 + self._rules_required = False + self._publicly_cloneable = None + self._has_scripts = False + self._requires_identity_verification = False + self._enable_team_files = False + self._team_file_deadline = None + self._team_merger_explicit_deadline = None + self._prohibit_new_entrants_explicit_deadline = None + self._kernels_publishing_disabled_deadline = None + self._disable_submissions = False + self._public_leaderboard_disclaimer_message = "" + self._has_leaderboard = False + self._disable_leaderboard_prize_indicator = False + self._withold_final_leaderboard_until_it_has_been_verified = False + self._final_leaderboard_has_been_verified = False + self._final_leaderboard_disclaimer_message = "" + self._only_allow_kernel_submissions = False + self._uses_synchronous_reruns = False + self._max_cpu_runtime_minutes = None + self._max_gpu_runtime_minutes = None + self._rerun_override_kernel_id = None + self._freeze() + + @property + def title(self) -> str: + """GENERAL SETTINGS GROUP (field numbers 1-19)""" + return self._title + + @title.setter + def title(self, title: str): + if title is None: + del self.title + return + if not isinstance(title, str): + raise TypeError('title must be of type str') + self._title = title + + @property + def brief_description(self) -> str: + """'Subtitle' in the UI.""" + return self._brief_description + + @brief_description.setter + def brief_description(self, brief_description: str): + if brief_description is None: + del self.brief_description + return + if not isinstance(brief_description, str): + raise TypeError('brief_description must be of type str') + self._brief_description = brief_description + + @property + def competition_name(self) -> str: + """ 'URL' in the UI.""" + return self._competition_name + + @competition_name.setter + def competition_name(self, competition_name: str): + if competition_name is None: + del self.competition_name + return + if not isinstance(competition_name, str): + raise TypeError('competition_name must be of type str') + self._competition_name = competition_name + + @property + def host_segment(self) -> 'HostSegment': + r""" + GENERAL SETTINGS GROUP: ADMIN ONLY + 'Category' in the UI. + """ + return self._host_segment + + @host_segment.setter + def host_segment(self, host_segment: 'HostSegment'): + if host_segment is None: + del self.host_segment + return + if not isinstance(host_segment, HostSegment): + raise TypeError('host_segment must be of type HostSegment') + self._host_segment = host_segment + + @property + def organization_id(self) -> int: + """ 'Creating As' in the UI.""" + return self._organization_id + + @organization_id.setter + def organization_id(self, organization_id: int): + if organization_id is None: + del self.organization_id + return + if not isinstance(organization_id, int): + raise TypeError('organization_id must be of type int') + self._organization_id = organization_id + + @property + def rules_required(self) -> bool: + """ 'Require Rules Agreement' in the UI.""" + return self._rules_required + + @rules_required.setter + def rules_required(self, rules_required: bool): + if rules_required is None: + del self.rules_required + return + if not isinstance(rules_required, bool): + raise TypeError('rules_required must be of type bool') + self._rules_required = rules_required + + @property + def publicly_cloneable(self) -> 'PubliclyCloneable': + """Indicates if a competition is marked for anyone to clone.""" + return self._publicly_cloneable or PubliclyCloneable.PUBLICLY_CLONEABLE_UNSPECIFIED + + @publicly_cloneable.setter + def publicly_cloneable(self, publicly_cloneable: Optional['PubliclyCloneable']): + if publicly_cloneable is None: + del self.publicly_cloneable + return + if not isinstance(publicly_cloneable, PubliclyCloneable): + raise TypeError('publicly_cloneable must be of type PubliclyCloneable') + self._publicly_cloneable = publicly_cloneable + + @property + def has_scripts(self) -> bool: + """ 'Enable Notebooks' in the UI.""" + return self._has_scripts + + @has_scripts.setter + def has_scripts(self, has_scripts: bool): + if has_scripts is None: + del self.has_scripts + return + if not isinstance(has_scripts, bool): + raise TypeError('has_scripts must be of type bool') + self._has_scripts = has_scripts + + @property + def requires_identity_verification(self) -> bool: + r""" + ACCESS & TEAMS SETTINGS GROUP: ADMIN ONLY + Whether identity verification with Persona is required to submit an entry + to the competition. + """ + return self._requires_identity_verification + + @requires_identity_verification.setter + def requires_identity_verification(self, requires_identity_verification: bool): + if requires_identity_verification is None: + del self.requires_identity_verification + return + if not isinstance(requires_identity_verification, bool): + raise TypeError('requires_identity_verification must be of type bool') + self._requires_identity_verification = requires_identity_verification + + @property + def enable_team_files(self) -> bool: + """'Enable Team File Drop' in the UI.""" + return self._enable_team_files + + @enable_team_files.setter + def enable_team_files(self, enable_team_files: bool): + if enable_team_files is None: + del self.enable_team_files + return + if not isinstance(enable_team_files, bool): + raise TypeError('enable_team_files must be of type bool') + self._enable_team_files = enable_team_files + + @property + def team_file_deadline(self) -> datetime: + r""" + TODO(aip.dev/142): (-- api-linter: core::0142::time-field-names=disabled + --) + Should only be set if enable_team_files is true. + Team File Drop Deadline' in the UI. + """ + return self._team_file_deadline + + @team_file_deadline.setter + def team_file_deadline(self, team_file_deadline: datetime): + if team_file_deadline is None: + del self.team_file_deadline + return + if not isinstance(team_file_deadline, datetime): + raise TypeError('team_file_deadline must be of type datetime') + self._team_file_deadline = team_file_deadline + + @property + def team_merger_explicit_deadline(self) -> datetime: + r""" + KEY DATES SETTINGS GROUP: ADMIN ONLY + 'Team Merger Deadline' in the UI. + TODO(aip.dev/142): (-- api-linter: core::0142::time-field-names=disabled + --) + """ + return self._team_merger_explicit_deadline + + @team_merger_explicit_deadline.setter + def team_merger_explicit_deadline(self, team_merger_explicit_deadline: datetime): + if team_merger_explicit_deadline is None: + del self.team_merger_explicit_deadline + return + if not isinstance(team_merger_explicit_deadline, datetime): + raise TypeError('team_merger_explicit_deadline must be of type datetime') + self._team_merger_explicit_deadline = team_merger_explicit_deadline + + @property + def prohibit_new_entrants_explicit_deadline(self) -> datetime: + r""" + 'New Entrants Deadline' in the UI. + TODO(b/409380918): prohibit_new_entrants may affect value of + TODO(aip.dev/142): (-- api-linter: core::0142::time-field-names=disabled + --) + """ + return self._prohibit_new_entrants_explicit_deadline + + @prohibit_new_entrants_explicit_deadline.setter + def prohibit_new_entrants_explicit_deadline(self, prohibit_new_entrants_explicit_deadline: datetime): + if prohibit_new_entrants_explicit_deadline is None: + del self.prohibit_new_entrants_explicit_deadline + return + if not isinstance(prohibit_new_entrants_explicit_deadline, datetime): + raise TypeError('prohibit_new_entrants_explicit_deadline must be of type datetime') + self._prohibit_new_entrants_explicit_deadline = prohibit_new_entrants_explicit_deadline + + @property + def kernels_publishing_disabled_deadline(self) -> datetime: + r""" + Whether publishing of Kernels associated with this competition is currently + disabled (derived from checking DisableKernelsPublishing and + KernelsPublishingDeadline). + Should only be set if has_scripts is true. + 'Disable Public Notebooks Until' in the UI. + """ + return self._kernels_publishing_disabled_deadline + + @kernels_publishing_disabled_deadline.setter + def kernels_publishing_disabled_deadline(self, kernels_publishing_disabled_deadline: datetime): + if kernels_publishing_disabled_deadline is None: + del self.kernels_publishing_disabled_deadline + return + if not isinstance(kernels_publishing_disabled_deadline, datetime): + raise TypeError('kernels_publishing_disabled_deadline must be of type datetime') + self._kernels_publishing_disabled_deadline = kernels_publishing_disabled_deadline + + @property + def disable_submissions(self) -> bool: + return self._disable_submissions + + @disable_submissions.setter + def disable_submissions(self, disable_submissions: bool): + if disable_submissions is None: + del self.disable_submissions + return + if not isinstance(disable_submissions, bool): + raise TypeError('disable_submissions must be of type bool') + self._disable_submissions = disable_submissions + + @property + def public_leaderboard_disclaimer_message(self) -> str: + return self._public_leaderboard_disclaimer_message + + @public_leaderboard_disclaimer_message.setter + def public_leaderboard_disclaimer_message(self, public_leaderboard_disclaimer_message: str): + if public_leaderboard_disclaimer_message is None: + del self.public_leaderboard_disclaimer_message + return + if not isinstance(public_leaderboard_disclaimer_message, str): + raise TypeError('public_leaderboard_disclaimer_message must be of type str') + self._public_leaderboard_disclaimer_message = public_leaderboard_disclaimer_message + + @property + def has_leaderboard(self) -> bool: + r""" + SUBMISSIONS & LEADERBOARD SETTINGS GROUP: ADMIN ONLY + 'Show Leaderboard' in the UI. + """ + return self._has_leaderboard + + @has_leaderboard.setter + def has_leaderboard(self, has_leaderboard: bool): + if has_leaderboard is None: + del self.has_leaderboard + return + if not isinstance(has_leaderboard, bool): + raise TypeError('has_leaderboard must be of type bool') + self._has_leaderboard = has_leaderboard + + @property + def disable_leaderboard_prize_indicator(self) -> bool: + """'Show Leaderboard Prize Indicator' in the UI.""" + return self._disable_leaderboard_prize_indicator + + @disable_leaderboard_prize_indicator.setter + def disable_leaderboard_prize_indicator(self, disable_leaderboard_prize_indicator: bool): + if disable_leaderboard_prize_indicator is None: + del self.disable_leaderboard_prize_indicator + return + if not isinstance(disable_leaderboard_prize_indicator, bool): + raise TypeError('disable_leaderboard_prize_indicator must be of type bool') + self._disable_leaderboard_prize_indicator = disable_leaderboard_prize_indicator + + @property + def withold_final_leaderboard_until_it_has_been_verified(self) -> bool: + """'Hold Final Leaderboard for Verification' in the UI.""" + return self._withold_final_leaderboard_until_it_has_been_verified + + @withold_final_leaderboard_until_it_has_been_verified.setter + def withold_final_leaderboard_until_it_has_been_verified(self, withold_final_leaderboard_until_it_has_been_verified: bool): + if withold_final_leaderboard_until_it_has_been_verified is None: + del self.withold_final_leaderboard_until_it_has_been_verified + return + if not isinstance(withold_final_leaderboard_until_it_has_been_verified, bool): + raise TypeError('withold_final_leaderboard_until_it_has_been_verified must be of type bool') + self._withold_final_leaderboard_until_it_has_been_verified = withold_final_leaderboard_until_it_has_been_verified + + @property + def final_leaderboard_has_been_verified(self) -> bool: + r""" + Should only be set if withold_final_leaderboard_until_it_has_been_verified + is true. + 'Final Leaderboard Verified' in the UI. + """ + return self._final_leaderboard_has_been_verified + + @final_leaderboard_has_been_verified.setter + def final_leaderboard_has_been_verified(self, final_leaderboard_has_been_verified: bool): + if final_leaderboard_has_been_verified is None: + del self.final_leaderboard_has_been_verified + return + if not isinstance(final_leaderboard_has_been_verified, bool): + raise TypeError('final_leaderboard_has_been_verified must be of type bool') + self._final_leaderboard_has_been_verified = final_leaderboard_has_been_verified + + @property + def final_leaderboard_disclaimer_message(self) -> str: + """'Private Leaderboard Disclaimer' in the UI.""" + return self._final_leaderboard_disclaimer_message + + @final_leaderboard_disclaimer_message.setter + def final_leaderboard_disclaimer_message(self, final_leaderboard_disclaimer_message: str): + if final_leaderboard_disclaimer_message is None: + del self.final_leaderboard_disclaimer_message + return + if not isinstance(final_leaderboard_disclaimer_message, str): + raise TypeError('final_leaderboard_disclaimer_message must be of type str') + self._final_leaderboard_disclaimer_message = final_leaderboard_disclaimer_message + + @property + def only_allow_kernel_submissions(self) -> bool: + r""" + CODE COMPETITION SETTINGS GROUP (field numbers 100-119) + 'Code Competition' in the UI. Whether competitors must submit a Notebook. + """ + return self._only_allow_kernel_submissions + + @only_allow_kernel_submissions.setter + def only_allow_kernel_submissions(self, only_allow_kernel_submissions: bool): + if only_allow_kernel_submissions is None: + del self.only_allow_kernel_submissions + return + if not isinstance(only_allow_kernel_submissions, bool): + raise TypeError('only_allow_kernel_submissions must be of type bool') + self._only_allow_kernel_submissions = only_allow_kernel_submissions + + @property + def uses_synchronous_reruns(self) -> bool: + """'Uses Synchronous Reruns' in the UI.""" + return self._uses_synchronous_reruns + + @uses_synchronous_reruns.setter + def uses_synchronous_reruns(self, uses_synchronous_reruns: bool): + if uses_synchronous_reruns is None: + del self.uses_synchronous_reruns + return + if not isinstance(uses_synchronous_reruns, bool): + raise TypeError('uses_synchronous_reruns must be of type bool') + self._uses_synchronous_reruns = uses_synchronous_reruns + + @property + def max_cpu_runtime_minutes(self) -> int: + """'Max CPU Runtime Minutes' in the UI.""" + return self._max_cpu_runtime_minutes or 0 + + @max_cpu_runtime_minutes.setter + def max_cpu_runtime_minutes(self, max_cpu_runtime_minutes: Optional[int]): + if max_cpu_runtime_minutes is None: + del self.max_cpu_runtime_minutes + return + if not isinstance(max_cpu_runtime_minutes, int): + raise TypeError('max_cpu_runtime_minutes must be of type int') + self._max_cpu_runtime_minutes = max_cpu_runtime_minutes + + @property + def max_gpu_runtime_minutes(self) -> int: + """'Max GPU Runtime Minutes' in the UI.""" + return self._max_gpu_runtime_minutes or 0 + + @max_gpu_runtime_minutes.setter + def max_gpu_runtime_minutes(self, max_gpu_runtime_minutes: Optional[int]): + if max_gpu_runtime_minutes is None: + del self.max_gpu_runtime_minutes + return + if not isinstance(max_gpu_runtime_minutes, int): + raise TypeError('max_gpu_runtime_minutes must be of type int') + self._max_gpu_runtime_minutes = max_gpu_runtime_minutes + + @property + def rerun_override_kernel_id(self) -> int: + r""" + Host-authored template Notebook the frontend wraps the user's artifact + (e.g. skill.md) into before submitting. Parallels + main_py_override_kernel_id. + """ + return self._rerun_override_kernel_id or 0 + + @rerun_override_kernel_id.setter + def rerun_override_kernel_id(self, rerun_override_kernel_id: Optional[int]): + if rerun_override_kernel_id is None: + del self.rerun_override_kernel_id + return + if not isinstance(rerun_override_kernel_id, int): + raise TypeError('rerun_override_kernel_id must be of type int') + self._rerun_override_kernel_id = rerun_override_kernel_id + + +class CreateCompetitionEmailInvitesRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + emails_to_add (str) + """ + + def __init__(self): + self._competition_id = 0 + self._emails_to_add = [] + self._freeze() + + @property + def competition_id(self) -> int: + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + @property + def emails_to_add(self) -> Optional[List[str]]: + return self._emails_to_add + + @emails_to_add.setter + def emails_to_add(self, emails_to_add: Optional[List[str]]): + if emails_to_add is None: + del self.emails_to_add + return + if not isinstance(emails_to_add, list): + raise TypeError('emails_to_add must be of type list') + if not all([isinstance(t, str) for t in emails_to_add]): + raise TypeError('emails_to_add must contain only items of type str') + self._emails_to_add = emails_to_add + + +class CreateCompetitionEmailInvitesResponse(KaggleObject): + r""" + Attributes: + email_invites (CompetitionEmailInvite) + """ + + def __init__(self): + self._email_invites = [] + self._freeze() + + @property + def email_invites(self) -> Optional[List[Optional['CompetitionEmailInvite']]]: + return self._email_invites + + @email_invites.setter + def email_invites(self, email_invites: Optional[List[Optional['CompetitionEmailInvite']]]): + if email_invites is None: + del self.email_invites + return + if not isinstance(email_invites, list): + raise TypeError('email_invites must be of type list') + if not all([isinstance(t, CompetitionEmailInvite) for t in email_invites]): + raise TypeError('email_invites must contain only items of type CompetitionEmailInvite') + self._email_invites = email_invites + + +class CreateCompetitionRequest(KaggleObject): + r""" + Attributes: + title (str) + slug (str) + brief_description (str) + host_segment (HostSegment) + privacy (CompetitionPrivacy) + clone_competition_id (int) + If present, we will clone from this competition, and copy over + several configuration settings, pages, dataset, evaluation setup, etc. + disable_kernels (bool) + restrict_link_to_email_list (bool) + restricts those who join the competition via share link to a specific list + of emails/domains + license_id (int) + organization_id (int) + Ties this competition to an organization, i.e. grants all members of an + organization read-only access to this competition. + clone_exclude_competition_data (bool) + If cloning, whether to exclude the competition's data (solution, sandbox + submissions, images, and databundles). + reward (Reward) + hackathon (bool) + If the competition should be a hackathon competition. + num_prizes (int) + TODO(b/372476849): Add num_prizes to Reward and clean up numPrizes. + clone_all_submissions (bool) + Admin-only. If cloning, copy all non-after-deadline submissions (not just + benchmark/sandbox ones), creating a new benchmark-style team for each. + """ + + def __init__(self): + self._title = "" + self._slug = "" + self._brief_description = "" + self._host_segment = HostSegment.HOST_SEGMENT_UNSPECIFIED + self._privacy = CompetitionPrivacy.COMPETITION_PRIVACY_UNSPECIFIED + self._clone_competition_id = None + self._disable_kernels = None + self._restrict_link_to_email_list = None + self._license_id = None + self._organization_id = None + self._clone_exclude_competition_data = None + self._reward = None + self._hackathon = None + self._num_prizes = None + self._clone_all_submissions = None + self._freeze() + + @property + def title(self) -> str: + return self._title + + @title.setter + def title(self, title: str): + if title is None: + del self.title + return + if not isinstance(title, str): + raise TypeError('title must be of type str') + self._title = title + + @property + def slug(self) -> str: + return self._slug + + @slug.setter + def slug(self, slug: str): + if slug is None: + del self.slug + return + if not isinstance(slug, str): + raise TypeError('slug must be of type str') + self._slug = slug + + @property + def brief_description(self) -> str: + return self._brief_description + + @brief_description.setter + def brief_description(self, brief_description: str): + if brief_description is None: + del self.brief_description + return + if not isinstance(brief_description, str): + raise TypeError('brief_description must be of type str') + self._brief_description = brief_description + + @property + def host_segment(self) -> 'HostSegment': + return self._host_segment + + @host_segment.setter + def host_segment(self, host_segment: 'HostSegment'): + if host_segment is None: + del self.host_segment + return + if not isinstance(host_segment, HostSegment): + raise TypeError('host_segment must be of type HostSegment') + self._host_segment = host_segment + + @property + def privacy(self) -> 'CompetitionPrivacy': + return self._privacy + + @privacy.setter + def privacy(self, privacy: 'CompetitionPrivacy'): + if privacy is None: + del self.privacy + return + if not isinstance(privacy, CompetitionPrivacy): + raise TypeError('privacy must be of type CompetitionPrivacy') + self._privacy = privacy + + @property + def clone_competition_id(self) -> int: + r""" + If present, we will clone from this competition, and copy over + several configuration settings, pages, dataset, evaluation setup, etc. + """ + return self._clone_competition_id or 0 + + @clone_competition_id.setter + def clone_competition_id(self, clone_competition_id: Optional[int]): + if clone_competition_id is None: + del self.clone_competition_id + return + if not isinstance(clone_competition_id, int): + raise TypeError('clone_competition_id must be of type int') + self._clone_competition_id = clone_competition_id + + @property + def disable_kernels(self) -> bool: + return self._disable_kernels or False + + @disable_kernels.setter + def disable_kernels(self, disable_kernels: Optional[bool]): + if disable_kernels is None: + del self.disable_kernels + return + if not isinstance(disable_kernels, bool): + raise TypeError('disable_kernels must be of type bool') + self._disable_kernels = disable_kernels + + @property + def restrict_link_to_email_list(self) -> bool: + r""" + restricts those who join the competition via share link to a specific list + of emails/domains + """ + return self._restrict_link_to_email_list or False + + @restrict_link_to_email_list.setter + def restrict_link_to_email_list(self, restrict_link_to_email_list: Optional[bool]): + if restrict_link_to_email_list is None: + del self.restrict_link_to_email_list + return + if not isinstance(restrict_link_to_email_list, bool): + raise TypeError('restrict_link_to_email_list must be of type bool') + self._restrict_link_to_email_list = restrict_link_to_email_list + + @property + def license_id(self) -> int: + return self._license_id or 0 + + @license_id.setter + def license_id(self, license_id: Optional[int]): + if license_id is None: + del self.license_id + return + if not isinstance(license_id, int): + raise TypeError('license_id must be of type int') + self._license_id = license_id + + @property + def organization_id(self) -> int: + r""" + Ties this competition to an organization, i.e. grants all members of an + organization read-only access to this competition. + """ + return self._organization_id or 0 + + @organization_id.setter + def organization_id(self, organization_id: Optional[int]): + if organization_id is None: + del self.organization_id + return + if not isinstance(organization_id, int): + raise TypeError('organization_id must be of type int') + self._organization_id = organization_id + + @property + def clone_exclude_competition_data(self) -> bool: + r""" + If cloning, whether to exclude the competition's data (solution, sandbox + submissions, images, and databundles). + """ + return self._clone_exclude_competition_data or False + + @clone_exclude_competition_data.setter + def clone_exclude_competition_data(self, clone_exclude_competition_data: Optional[bool]): + if clone_exclude_competition_data is None: + del self.clone_exclude_competition_data + return + if not isinstance(clone_exclude_competition_data, bool): + raise TypeError('clone_exclude_competition_data must be of type bool') + self._clone_exclude_competition_data = clone_exclude_competition_data + + @property + def reward(self) -> Optional['Reward']: + return self._reward or None + + @reward.setter + def reward(self, reward: Optional[Optional['Reward']]): + if reward is None: + del self.reward + return + if not isinstance(reward, Reward): + raise TypeError('reward must be of type Reward') + self._reward = reward + + @property + def hackathon(self) -> bool: + """If the competition should be a hackathon competition.""" + return self._hackathon or False + + @hackathon.setter + def hackathon(self, hackathon: Optional[bool]): + if hackathon is None: + del self.hackathon + return + if not isinstance(hackathon, bool): + raise TypeError('hackathon must be of type bool') + self._hackathon = hackathon + + @property + def num_prizes(self) -> int: + """TODO(b/372476849): Add num_prizes to Reward and clean up numPrizes.""" + return self._num_prizes or 0 + + @num_prizes.setter + def num_prizes(self, num_prizes: Optional[int]): + if num_prizes is None: + del self.num_prizes + return + if not isinstance(num_prizes, int): + raise TypeError('num_prizes must be of type int') + self._num_prizes = num_prizes + + @property + def clone_all_submissions(self) -> bool: + r""" + Admin-only. If cloning, copy all non-after-deadline submissions (not just + benchmark/sandbox ones), creating a new benchmark-style team for each. + """ + return self._clone_all_submissions or False + + @clone_all_submissions.setter + def clone_all_submissions(self, clone_all_submissions: Optional[bool]): + if clone_all_submissions is None: + del self.clone_all_submissions + return + if not isinstance(clone_all_submissions, bool): + raise TypeError('clone_all_submissions must be of type bool') + self._clone_all_submissions = clone_all_submissions + + +class CreateCompetitionResponse(KaggleObject): + r""" + Attributes: + competition (Competition) + """ + + def __init__(self): + self._competition = None + self._freeze() + + @property + def competition(self) -> Optional['Competition']: + return self._competition + + @competition.setter + def competition(self, competition: Optional['Competition']): + if competition is None: + del self.competition + return + if not isinstance(competition, Competition): + raise TypeError('competition must be of type Competition') + self._competition = competition + + +class CreateCompetitionSampleSubmissionRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + blob_token (str) + """ + + def __init__(self): + self._competition_id = 0 + self._blob_token = "" + self._freeze() + + @property + def competition_id(self) -> int: + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + @property + def blob_token(self) -> str: + return self._blob_token + + @blob_token.setter + def blob_token(self, blob_token: str): + if blob_token is None: + del self.blob_token + return + if not isinstance(blob_token, str): + raise TypeError('blob_token must be of type str') + self._blob_token = blob_token + + +class CreateCompetitionSolutionRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + blob_token (str) + """ + + def __init__(self): + self._competition_id = 0 + self._blob_token = "" + self._freeze() + + @property + def competition_id(self) -> int: + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + @property + def blob_token(self) -> str: + return self._blob_token + + @blob_token.setter + def blob_token(self, blob_token: str): + if blob_token is None: + del self.blob_token + return + if not isinstance(blob_token, str): + raise TypeError('blob_token must be of type str') + self._blob_token = blob_token + + +class CreateHarnessKernelRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + github_source (GithubFileInfo) + Optional GitHub source to seed the kernel from. When set, the handler + fetches the file via the public GitHub API and uses its content as the + initial kernel source. If the file doesn't exist, an empty kernel is + created. Only the owner/repo/path/ref fields are read; raw_url/size are + ignored. + """ + + def __init__(self): + self._competition_id = 0 + self._github_source = None + self._freeze() + + @property + def competition_id(self) -> int: + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + @property + def github_source(self) -> Optional['GithubFileInfo']: + r""" + Optional GitHub source to seed the kernel from. When set, the handler + fetches the file via the public GitHub API and uses its content as the + initial kernel source. If the file doesn't exist, an empty kernel is + created. Only the owner/repo/path/ref fields are read; raw_url/size are + ignored. + """ + return self._github_source or None + + @github_source.setter + def github_source(self, github_source: Optional[Optional['GithubFileInfo']]): + if github_source is None: + del self.github_source + return + if not isinstance(github_source, GithubFileInfo): + raise TypeError('github_source must be of type GithubFileInfo') + self._github_source = github_source + + +class CreateHarnessKernelResponse(KaggleObject): + r""" + Attributes: + kernel_id (int) + """ + + def __init__(self): + self._kernel_id = 0 + self._freeze() + + @property + def kernel_id(self) -> int: + return self._kernel_id + + @kernel_id.setter + def kernel_id(self, kernel_id: int): + if kernel_id is None: + del self.kernel_id + return + if not isinstance(kernel_id, int): + raise TypeError('kernel_id must be of type int') + self._kernel_id = kernel_id + + +class DeleteCompetitionEmailInviteRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + email_invite_id (int) + """ + + def __init__(self): + self._competition_id = 0 + self._email_invite_id = 0 + self._freeze() + + @property + def competition_id(self) -> int: + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + @property + def email_invite_id(self) -> int: + return self._email_invite_id + + @email_invite_id.setter + def email_invite_id(self, email_invite_id: int): + if email_invite_id is None: + del self.email_invite_id + return + if not isinstance(email_invite_id, int): + raise TypeError('email_invite_id must be of type int') + self._email_invite_id = email_invite_id + + +class DeleteCompetitionRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + """ + + def __init__(self): + self._competition_id = 0 + self._freeze() + + @property + def competition_id(self) -> int: + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + +class DeleteCompetitionResponse(KaggleObject): + r""" + """ + + pass + +class DeleteSolutionFilesRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + """ + + def __init__(self): + self._competition_id = 0 + self._freeze() + + @property + def competition_id(self) -> int: + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + +class GetCompetitionSimulationSettingsRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + """ + + def __init__(self): + self._competition_id = 0 + self._freeze() + + @property + def competition_id(self) -> int: + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + +class GetDatabundleBasicInfoRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + """ + + def __init__(self): + self._competition_id = 0 + self._freeze() + + @property + def competition_id(self) -> int: + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + +class GetPrivacySettingsRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + """ + + def __init__(self): + self._competition_id = 0 + self._freeze() + + @property + def competition_id(self) -> int: + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + +class LaunchCompetitionRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + future_time (datetime) + Optional time in the future to launch the competition rather than launching + it immediately. + """ + + def __init__(self): + self._competition_id = 0 + self._future_time = None + self._freeze() + + @property + def competition_id(self) -> int: + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + @property + def future_time(self) -> datetime: + r""" + Optional time in the future to launch the competition rather than launching + it immediately. + """ + return self._future_time + + @future_time.setter + def future_time(self, future_time: datetime): + if future_time is None: + del self.future_time + return + if not isinstance(future_time, datetime): + raise TypeError('future_time must be of type datetime') + self._future_time = future_time + + +class ListCompetitionEmailInvitesRequest(KaggleObject): + r""" + TODO(aip.dev/158): (-- api-linter: + core::0158::request-page-size-field=disabled --) + TODO(aip.dev/158): (-- api-linter: + core::0158::request-page-token-field=disabled --) + + Attributes: + competition_id (int) + """ + + def __init__(self): + self._competition_id = 0 + self._freeze() + + @property + def competition_id(self) -> int: + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + +class ListCompetitionEmailInvitesResponse(KaggleObject): + r""" + TODO(aip.dev/158): (-- api-linter: + core::0158::response-next-page-token-field=disabled --) + + Attributes: + email_invites (CompetitionEmailInvite) + """ + + def __init__(self): + self._email_invites = [] + self._freeze() + + @property + def email_invites(self) -> Optional[List[Optional['CompetitionEmailInvite']]]: + return self._email_invites + + @email_invites.setter + def email_invites(self, email_invites: Optional[List[Optional['CompetitionEmailInvite']]]): + if email_invites is None: + del self.email_invites + return + if not isinstance(email_invites, list): + raise TypeError('email_invites must be of type list') + if not all([isinstance(t, CompetitionEmailInvite) for t in email_invites]): + raise TypeError('email_invites must contain only items of type CompetitionEmailInvite') + self._email_invites = email_invites + + +class ListCompetitionLicensesRequest(KaggleObject): + r""" + TODO(aip.dev/158): (-- api-linter: + core::0158::request-page-size-field=disabled --) + TODO(aip.dev/158): (-- api-linter: + core::0158::request-page-token-field=disabled --) + + """ + + pass + +class ListCompetitionLicensesResponse(KaggleObject): + r""" + TODO(aip.dev/158): (-- api-linter: + core::0158::response-next-page-token-field=disabled --) + + Attributes: + licenses (LicenseOption) + """ + + def __init__(self): + self._licenses = [] + self._freeze() + + @property + def licenses(self) -> Optional[List[Optional['LicenseOption']]]: + return self._licenses + + @licenses.setter + def licenses(self, licenses: Optional[List[Optional['LicenseOption']]]): + if licenses is None: + del self.licenses + return + if not isinstance(licenses, list): + raise TypeError('licenses must be of type list') + if not all([isinstance(t, LicenseOption) for t in licenses]): + raise TypeError('licenses must contain only items of type LicenseOption') + self._licenses = licenses + + +class ListHostUsersRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + """ + + def __init__(self): + self._competition_id = 0 + self._freeze() + + @property + def competition_id(self) -> int: + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + +class ListHostUsersResponse(KaggleObject): + r""" + Attributes: + hosts (UserAvatar) + """ + + def __init__(self): + self._hosts = [] + self._freeze() + + @property + def hosts(self) -> Optional[List[Optional['UserAvatar']]]: + return self._hosts + + @hosts.setter + def hosts(self, hosts: Optional[List[Optional['UserAvatar']]]): + if hosts is None: + del self.hosts + return + if not isinstance(hosts, list): + raise TypeError('hosts must be of type list') + if not all([isinstance(t, UserAvatar) for t in hosts]): + raise TypeError('hosts must contain only items of type UserAvatar') + self._hosts = hosts + + +class RegenerateShareTokenRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + """ + + def __init__(self): + self._competition_id = 0 + self._freeze() + + @property + def competition_id(self) -> int: + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + +class RemoveHostUserRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + host_user_id (int) + """ + + def __init__(self): + self._competition_id = 0 + self._host_user_id = 0 + self._freeze() + + @property + def competition_id(self) -> int: + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + @property + def host_user_id(self) -> int: + return self._host_user_id + + @host_user_id.setter + def host_user_id(self, host_user_id: int): + if host_user_id is None: + del self.host_user_id + return + if not isinstance(host_user_id, int): + raise TypeError('host_user_id must be of type int') + self._host_user_id = host_user_id + + +class SetCompetitionCitationAuthorsRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + authors (str) + """ + + def __init__(self): + self._competition_id = 0 + self._authors = "" + self._freeze() + + @property + def competition_id(self) -> int: + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + @property + def authors(self) -> str: + return self._authors + + @authors.setter + def authors(self, authors: str): + if authors is None: + del self.authors + return + if not isinstance(authors, str): + raise TypeError('authors must be of type str') + self._authors = authors + + +class SetCompetitionMetricRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + evaluation_algorithm_id (int) + """ + + def __init__(self): + self._competition_id = 0 + self._evaluation_algorithm_id = 0 + self._freeze() + + @property + def competition_id(self) -> int: + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + @property + def evaluation_algorithm_id(self) -> int: + return self._evaluation_algorithm_id + + @evaluation_algorithm_id.setter + def evaluation_algorithm_id(self, evaluation_algorithm_id: int): + if evaluation_algorithm_id is None: + del self.evaluation_algorithm_id + return + if not isinstance(evaluation_algorithm_id, int): + raise TypeError('evaluation_algorithm_id must be of type int') + self._evaluation_algorithm_id = evaluation_algorithm_id + + +class SetCompetitionMetricResponse(KaggleObject): + r""" + Attributes: + metric (EvaluationAlgorithm) + metric_version (CompetitionMetricVersion) + """ + + def __init__(self): + self._metric = None + self._metric_version = None + self._freeze() + + @property + def metric(self) -> Optional['EvaluationAlgorithm']: + return self._metric + + @metric.setter + def metric(self, metric: Optional['EvaluationAlgorithm']): + if metric is None: + del self.metric + return + if not isinstance(metric, EvaluationAlgorithm): + raise TypeError('metric must be of type EvaluationAlgorithm') + self._metric = metric + + @property + def metric_version(self) -> Optional['CompetitionMetricVersion']: + return self._metric_version + + @metric_version.setter + def metric_version(self, metric_version: Optional['CompetitionMetricVersion']): + if metric_version is None: + del self.metric_version + return + if not isinstance(metric_version, CompetitionMetricVersion): + raise TypeError('metric_version must be of type CompetitionMetricVersion') + self._metric_version = metric_version + + +class SetEvaluationMetricParametersRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + name_value_pairs (str) + """ + + def __init__(self): + self._competition_id = 0 + self._name_value_pairs = {} + self._freeze() + + @property + def competition_id(self) -> int: + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + @property + def name_value_pairs(self) -> Optional[Dict[str, str]]: + return self._name_value_pairs + + @name_value_pairs.setter + def name_value_pairs(self, name_value_pairs: Optional[Dict[str, str]]): + if name_value_pairs is None: + del self.name_value_pairs + return + if not isinstance(name_value_pairs, dict): + raise TypeError('name_value_pairs must be of type dict') + if not all([isinstance(v, str) for k, v in name_value_pairs]): + raise TypeError('name_value_pairs must contain only items of type str') + self._name_value_pairs = name_value_pairs + + +class ToggleBenchmarkSubmissionRequest(KaggleObject): + r""" + Attributes: + submission_id (int) + """ + + def __init__(self): + self._submission_id = 0 + self._freeze() + + @property + def submission_id(self) -> int: + return self._submission_id + + @submission_id.setter + def submission_id(self, submission_id: int): + if submission_id is None: + del self.submission_id + return + if not isinstance(submission_id, int): + raise TypeError('submission_id must be of type int') + self._submission_id = submission_id + + +class UpdateCompetitionSettingsRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + Specifies which Competition to update. Required. + settings (CompetitionSettings) + Specifies the data in the Competition to update. + update_mask (FieldMask) + Specifies which fields the caller wants to update. Required. + """ + + def __init__(self): + self._competition_id = 0 + self._settings = None + self._update_mask = None + self._freeze() + + @property + def competition_id(self) -> int: + """Specifies which Competition to update. Required.""" + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + @property + def settings(self) -> Optional['CompetitionSettings']: + """Specifies the data in the Competition to update.""" + return self._settings + + @settings.setter + def settings(self, settings: Optional['CompetitionSettings']): + if settings is None: + del self.settings + return + if not isinstance(settings, CompetitionSettings): + raise TypeError('settings must be of type CompetitionSettings') + self._settings = settings + + @property + def update_mask(self) -> FieldMask: + """Specifies which fields the caller wants to update. Required.""" + return self._update_mask + + @update_mask.setter + def update_mask(self, update_mask: FieldMask): + if update_mask is None: + del self.update_mask + return + if not isinstance(update_mask, FieldMask): + raise TypeError('update_mask must be of type FieldMask') + self._update_mask = update_mask + + +class UpdateCompetitionSettingsResponse(KaggleObject): + r""" + Attributes: + settings (CompetitionSettings) + Updated competition settings. + """ + + def __init__(self): + self._settings = None + self._freeze() + + @property + def settings(self) -> Optional['CompetitionSettings']: + """Updated competition settings.""" + return self._settings + + @settings.setter + def settings(self, settings: Optional['CompetitionSettings']): + if settings is None: + del self.settings + return + if not isinstance(settings, CompetitionSettings): + raise TypeError('settings must be of type CompetitionSettings') + self._settings = settings + + +class UpdateCompetitionSimulationSettingsRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + settings (CompetitionSimulationSettings) + """ + + def __init__(self): + self._competition_id = 0 + self._settings = None + self._freeze() + + @property + def competition_id(self) -> int: + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + @property + def settings(self) -> Optional['CompetitionSimulationSettings']: + return self._settings + + @settings.setter + def settings(self, settings: Optional['CompetitionSimulationSettings']): + if settings is None: + del self.settings + return + if not isinstance(settings, CompetitionSimulationSettings): + raise TypeError('settings must be of type CompetitionSimulationSettings') + self._settings = settings + + +class UpdateCurrentCompetitionMetricVersionRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + For now we only support updating to the latest version of the metric + currently set on the Competition. + """ + + def __init__(self): + self._competition_id = 0 + self._freeze() + + @property + def competition_id(self) -> int: + r""" + For now we only support updating to the latest version of the metric + currently set on the Competition. + """ + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + +class UpdateCurrentCompetitionMetricVersionResponse(KaggleObject): + r""" + Attributes: + competition_metric_version (CompetitionMetricVersion) + The metric version which is now set on the Competition. + parameters (EvaluationMetricParameter) + The latest hyperparameter values on the Competition. + """ + + def __init__(self): + self._competition_metric_version = None + self._parameters = [] + self._freeze() + + @property + def competition_metric_version(self) -> Optional['CompetitionMetricVersion']: + """The metric version which is now set on the Competition.""" + return self._competition_metric_version + + @competition_metric_version.setter + def competition_metric_version(self, competition_metric_version: Optional['CompetitionMetricVersion']): + if competition_metric_version is None: + del self.competition_metric_version + return + if not isinstance(competition_metric_version, CompetitionMetricVersion): + raise TypeError('competition_metric_version must be of type CompetitionMetricVersion') + self._competition_metric_version = competition_metric_version + + @property + def parameters(self) -> Optional[List[Optional['EvaluationMetricParameter']]]: + """The latest hyperparameter values on the Competition.""" + return self._parameters + + @parameters.setter + def parameters(self, parameters: Optional[List[Optional['EvaluationMetricParameter']]]): + if parameters is None: + del self.parameters + return + if not isinstance(parameters, list): + raise TypeError('parameters must be of type list') + if not all([isinstance(t, EvaluationMetricParameter) for t in parameters]): + raise TypeError('parameters must contain only items of type EvaluationMetricParameter') + self._parameters = parameters + + +class UpdateImagesRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + header (CroppedImageUpload) + thumbnail (CroppedImageUpload) + """ + + def __init__(self): + self._competition_id = 0 + self._header = None + self._thumbnail = None + self._freeze() + + @property + def competition_id(self) -> int: + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + @property + def header(self) -> Optional['CroppedImageUpload']: + return self._header + + @header.setter + def header(self, header: Optional['CroppedImageUpload']): + if header is None: + del self.header + return + if not isinstance(header, CroppedImageUpload): + raise TypeError('header must be of type CroppedImageUpload') + self._header = header + + @property + def thumbnail(self) -> Optional['CroppedImageUpload']: + return self._thumbnail + + @thumbnail.setter + def thumbnail(self, thumbnail: Optional['CroppedImageUpload']): + if thumbnail is None: + del self.thumbnail + return + if not isinstance(thumbnail, CroppedImageUpload): + raise TypeError('thumbnail must be of type CroppedImageUpload') + self._thumbnail = thumbnail + + +class UpdateImagesResponse(KaggleObject): + r""" + Attributes: + cover_image_url (str) + thumbnail_image_url (str) + """ + + def __init__(self): + self._cover_image_url = None + self._thumbnail_image_url = None + self._freeze() + + @property + def cover_image_url(self) -> str: + return self._cover_image_url or "" + + @cover_image_url.setter + def cover_image_url(self, cover_image_url: Optional[str]): + if cover_image_url is None: + del self.cover_image_url + return + if not isinstance(cover_image_url, str): + raise TypeError('cover_image_url must be of type str') + self._cover_image_url = cover_image_url + + @property + def thumbnail_image_url(self) -> str: + return self._thumbnail_image_url or "" + + @thumbnail_image_url.setter + def thumbnail_image_url(self, thumbnail_image_url: Optional[str]): + if thumbnail_image_url is None: + del self.thumbnail_image_url + return + if not isinstance(thumbnail_image_url, str): + raise TypeError('thumbnail_image_url must be of type str') + self._thumbnail_image_url = thumbnail_image_url + + +class UpdateSandboxSubmissionNameRequest(KaggleObject): + r""" + Attributes: + submission_id (int) + name (str) + """ + + def __init__(self): + self._submission_id = 0 + self._name = "" + self._freeze() + + @property + def submission_id(self) -> int: + return self._submission_id + + @submission_id.setter + def submission_id(self, submission_id: int): + if submission_id is None: + del self.submission_id + return + if not isinstance(submission_id, int): + raise TypeError('submission_id must be of type int') + self._submission_id = submission_id + + @property + def name(self) -> str: + return self._name + + @name.setter + def name(self, name: str): + if name is None: + del self.name + return + if not isinstance(name, str): + raise TypeError('name must be of type str') + self._name = name + + +class UpdateTeamsVisibilityRequest(KaggleObject): + r""" + Attributes: + competition_id (int) + All teams must be from this competition + team_ids (int) + hide (bool) + """ + + def __init__(self): + self._competition_id = 0 + self._team_ids = [] + self._hide = False + self._freeze() + + @property + def competition_id(self) -> int: + """All teams must be from this competition""" + return self._competition_id + + @competition_id.setter + def competition_id(self, competition_id: int): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError('competition_id must be of type int') + self._competition_id = competition_id + + @property + def team_ids(self) -> Optional[List[int]]: + return self._team_ids + + @team_ids.setter + def team_ids(self, team_ids: Optional[List[int]]): + if team_ids is None: + del self.team_ids + return + if not isinstance(team_ids, list): + raise TypeError('team_ids must be of type list') + if not all([isinstance(t, int) for t in team_ids]): + raise TypeError('team_ids must contain only items of type int') + self._team_ids = team_ids + + @property + def hide(self) -> bool: + return self._hide + + @hide.setter + def hide(self, hide: bool): + if hide is None: + del self.hide + return + if not isinstance(hide, bool): + raise TypeError('hide must be of type bool') + self._hide = hide + + +AddHostUserRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), + FieldMetadata("hostUserId", "host_user_id", "_host_user_id", int, 0, PredefinedSerializer()), +] + +ClaimCompetitionSyntheticCopyRequest._fields = [ + FieldMetadata("baseCompetitionId", "base_competition_id", "_base_competition_id", int, 0, PredefinedSerializer()), + FieldMetadata("title", "title", "_title", str, "", PredefinedSerializer()), + FieldMetadata("slug", "slug", "_slug", str, "", PredefinedSerializer()), + FieldMetadata("briefDescription", "brief_description", "_brief_description", str, "", PredefinedSerializer()), + FieldMetadata("privacy", "privacy", "_privacy", CompetitionPrivacy, CompetitionPrivacy.COMPETITION_PRIVACY_UNSPECIFIED, EnumSerializer()), + FieldMetadata("disableKernels", "disable_kernels", "_disable_kernels", bool, None, PredefinedSerializer(), optional=True), + FieldMetadata("restrictLinkToEmailList", "restrict_link_to_email_list", "_restrict_link_to_email_list", bool, None, PredefinedSerializer(), optional=True), + FieldMetadata("reward", "reward", "_reward", Reward, None, KaggleObjectSerializer(), optional=True), + FieldMetadata("hostSegment", "host_segment", "_host_segment", HostSegment, None, EnumSerializer(), optional=True), +] + +ClaimCompetitionSyntheticCopyResponse._fields = [ + FieldMetadata("claimedCompetitionId", "claimed_competition_id", "_claimed_competition_id", int, 0, PredefinedSerializer()), +] + +CompetitionSettings._fields = [ + FieldMetadata("title", "title", "_title", str, "", PredefinedSerializer()), + FieldMetadata("briefDescription", "brief_description", "_brief_description", str, "", PredefinedSerializer()), + FieldMetadata("competitionName", "competition_name", "_competition_name", str, "", PredefinedSerializer()), + FieldMetadata("hostSegment", "host_segment", "_host_segment", HostSegment, HostSegment.HOST_SEGMENT_UNSPECIFIED, EnumSerializer()), + FieldMetadata("organizationId", "organization_id", "_organization_id", int, 0, PredefinedSerializer()), + FieldMetadata("rulesRequired", "rules_required", "_rules_required", bool, False, PredefinedSerializer()), + FieldMetadata("publiclyCloneable", "publicly_cloneable", "_publicly_cloneable", PubliclyCloneable, None, EnumSerializer(), optional=True), + FieldMetadata("hasScripts", "has_scripts", "_has_scripts", bool, False, PredefinedSerializer()), + FieldMetadata("requiresIdentityVerification", "requires_identity_verification", "_requires_identity_verification", bool, False, PredefinedSerializer()), + FieldMetadata("enableTeamFiles", "enable_team_files", "_enable_team_files", bool, False, PredefinedSerializer()), + FieldMetadata("teamFileDeadline", "team_file_deadline", "_team_file_deadline", datetime, None, DateTimeSerializer()), + FieldMetadata("teamMergerExplicitDeadline", "team_merger_explicit_deadline", "_team_merger_explicit_deadline", datetime, None, DateTimeSerializer()), + FieldMetadata("prohibitNewEntrantsExplicitDeadline", "prohibit_new_entrants_explicit_deadline", "_prohibit_new_entrants_explicit_deadline", datetime, None, DateTimeSerializer()), + FieldMetadata("kernelsPublishingDisabledDeadline", "kernels_publishing_disabled_deadline", "_kernels_publishing_disabled_deadline", datetime, None, DateTimeSerializer()), + FieldMetadata("disableSubmissions", "disable_submissions", "_disable_submissions", bool, False, PredefinedSerializer()), + FieldMetadata("publicLeaderboardDisclaimerMessage", "public_leaderboard_disclaimer_message", "_public_leaderboard_disclaimer_message", str, "", PredefinedSerializer()), + FieldMetadata("hasLeaderboard", "has_leaderboard", "_has_leaderboard", bool, False, PredefinedSerializer()), + FieldMetadata("disableLeaderboardPrizeIndicator", "disable_leaderboard_prize_indicator", "_disable_leaderboard_prize_indicator", bool, False, PredefinedSerializer()), + FieldMetadata("witholdFinalLeaderboardUntilItHasBeenVerified", "withold_final_leaderboard_until_it_has_been_verified", "_withold_final_leaderboard_until_it_has_been_verified", bool, False, PredefinedSerializer()), + FieldMetadata("finalLeaderboardHasBeenVerified", "final_leaderboard_has_been_verified", "_final_leaderboard_has_been_verified", bool, False, PredefinedSerializer()), + FieldMetadata("finalLeaderboardDisclaimerMessage", "final_leaderboard_disclaimer_message", "_final_leaderboard_disclaimer_message", str, "", PredefinedSerializer()), + FieldMetadata("onlyAllowKernelSubmissions", "only_allow_kernel_submissions", "_only_allow_kernel_submissions", bool, False, PredefinedSerializer()), + FieldMetadata("usesSynchronousReruns", "uses_synchronous_reruns", "_uses_synchronous_reruns", bool, False, PredefinedSerializer()), + FieldMetadata("maxCpuRuntimeMinutes", "max_cpu_runtime_minutes", "_max_cpu_runtime_minutes", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("maxGpuRuntimeMinutes", "max_gpu_runtime_minutes", "_max_gpu_runtime_minutes", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("rerunOverrideKernelId", "rerun_override_kernel_id", "_rerun_override_kernel_id", int, None, PredefinedSerializer(), optional=True), +] + +CreateCompetitionEmailInvitesRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), + FieldMetadata("emailsToAdd", "emails_to_add", "_emails_to_add", str, [], ListSerializer(PredefinedSerializer())), +] + +CreateCompetitionEmailInvitesResponse._fields = [ + FieldMetadata("emailInvites", "email_invites", "_email_invites", CompetitionEmailInvite, [], ListSerializer(KaggleObjectSerializer())), +] + +CreateCompetitionRequest._fields = [ + FieldMetadata("title", "title", "_title", str, "", PredefinedSerializer()), + FieldMetadata("slug", "slug", "_slug", str, "", PredefinedSerializer()), + FieldMetadata("briefDescription", "brief_description", "_brief_description", str, "", PredefinedSerializer()), + FieldMetadata("hostSegment", "host_segment", "_host_segment", HostSegment, HostSegment.HOST_SEGMENT_UNSPECIFIED, EnumSerializer()), + FieldMetadata("privacy", "privacy", "_privacy", CompetitionPrivacy, CompetitionPrivacy.COMPETITION_PRIVACY_UNSPECIFIED, EnumSerializer()), + FieldMetadata("cloneCompetitionId", "clone_competition_id", "_clone_competition_id", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("disableKernels", "disable_kernels", "_disable_kernels", bool, None, PredefinedSerializer(), optional=True), + FieldMetadata("restrictLinkToEmailList", "restrict_link_to_email_list", "_restrict_link_to_email_list", bool, None, PredefinedSerializer(), optional=True), + FieldMetadata("licenseId", "license_id", "_license_id", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("organizationId", "organization_id", "_organization_id", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("cloneExcludeCompetitionData", "clone_exclude_competition_data", "_clone_exclude_competition_data", bool, None, PredefinedSerializer(), optional=True), + FieldMetadata("reward", "reward", "_reward", Reward, None, KaggleObjectSerializer(), optional=True), + FieldMetadata("hackathon", "hackathon", "_hackathon", bool, None, PredefinedSerializer(), optional=True), + FieldMetadata("numPrizes", "num_prizes", "_num_prizes", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("cloneAllSubmissions", "clone_all_submissions", "_clone_all_submissions", bool, None, PredefinedSerializer(), optional=True), +] + +CreateCompetitionResponse._fields = [ + FieldMetadata("competition", "competition", "_competition", Competition, None, KaggleObjectSerializer()), +] + +CreateCompetitionSampleSubmissionRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), + FieldMetadata("blobToken", "blob_token", "_blob_token", str, "", PredefinedSerializer()), +] + +CreateCompetitionSolutionRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), + FieldMetadata("blobToken", "blob_token", "_blob_token", str, "", PredefinedSerializer()), +] + +CreateHarnessKernelRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), + FieldMetadata("githubSource", "github_source", "_github_source", GithubFileInfo, None, KaggleObjectSerializer(), optional=True), +] + +CreateHarnessKernelResponse._fields = [ + FieldMetadata("kernelId", "kernel_id", "_kernel_id", int, 0, PredefinedSerializer()), +] + +DeleteCompetitionEmailInviteRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), + FieldMetadata("emailInviteId", "email_invite_id", "_email_invite_id", int, 0, PredefinedSerializer()), +] + +DeleteCompetitionRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), +] + +DeleteCompetitionResponse._fields = [] + +DeleteSolutionFilesRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), +] + +GetCompetitionSimulationSettingsRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), +] + +GetDatabundleBasicInfoRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), +] + +GetPrivacySettingsRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), +] + +LaunchCompetitionRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), + FieldMetadata("futureTime", "future_time", "_future_time", datetime, None, DateTimeSerializer()), +] + +ListCompetitionEmailInvitesRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), +] + +ListCompetitionEmailInvitesResponse._fields = [ + FieldMetadata("emailInvites", "email_invites", "_email_invites", CompetitionEmailInvite, [], ListSerializer(KaggleObjectSerializer())), +] + +ListCompetitionLicensesRequest._fields = [] + +ListCompetitionLicensesResponse._fields = [ + FieldMetadata("licenses", "licenses", "_licenses", LicenseOption, [], ListSerializer(KaggleObjectSerializer())), +] + +ListHostUsersRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), +] + +ListHostUsersResponse._fields = [ + FieldMetadata("hosts", "hosts", "_hosts", UserAvatar, [], ListSerializer(KaggleObjectSerializer())), +] + +RegenerateShareTokenRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), +] + +RemoveHostUserRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), + FieldMetadata("hostUserId", "host_user_id", "_host_user_id", int, 0, PredefinedSerializer()), +] + +SetCompetitionCitationAuthorsRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), + FieldMetadata("authors", "authors", "_authors", str, "", PredefinedSerializer()), +] + +SetCompetitionMetricRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), + FieldMetadata("evaluationAlgorithmId", "evaluation_algorithm_id", "_evaluation_algorithm_id", int, 0, PredefinedSerializer()), +] + +SetCompetitionMetricResponse._fields = [ + FieldMetadata("metric", "metric", "_metric", EvaluationAlgorithm, None, KaggleObjectSerializer()), + FieldMetadata("metricVersion", "metric_version", "_metric_version", CompetitionMetricVersion, None, KaggleObjectSerializer()), +] + +SetEvaluationMetricParametersRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), + FieldMetadata("nameValuePairs", "name_value_pairs", "_name_value_pairs", str, {}, MapSerializer(PredefinedSerializer())), +] + +ToggleBenchmarkSubmissionRequest._fields = [ + FieldMetadata("submissionId", "submission_id", "_submission_id", int, 0, PredefinedSerializer()), +] + +UpdateCompetitionSettingsRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), + FieldMetadata("settings", "settings", "_settings", CompetitionSettings, None, KaggleObjectSerializer()), + FieldMetadata("updateMask", "update_mask", "_update_mask", FieldMask, None, FieldMaskSerializer()), +] + +UpdateCompetitionSettingsResponse._fields = [ + FieldMetadata("settings", "settings", "_settings", CompetitionSettings, None, KaggleObjectSerializer()), +] + +UpdateCompetitionSimulationSettingsRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), + FieldMetadata("settings", "settings", "_settings", CompetitionSimulationSettings, None, KaggleObjectSerializer()), +] + +UpdateCurrentCompetitionMetricVersionRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), +] + +UpdateCurrentCompetitionMetricVersionResponse._fields = [ + FieldMetadata("competitionMetricVersion", "competition_metric_version", "_competition_metric_version", CompetitionMetricVersion, None, KaggleObjectSerializer()), + FieldMetadata("parameters", "parameters", "_parameters", EvaluationMetricParameter, [], ListSerializer(KaggleObjectSerializer())), +] + +UpdateImagesRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), + FieldMetadata("header", "header", "_header", CroppedImageUpload, None, KaggleObjectSerializer()), + FieldMetadata("thumbnail", "thumbnail", "_thumbnail", CroppedImageUpload, None, KaggleObjectSerializer()), +] + +UpdateImagesResponse._fields = [ + FieldMetadata("coverImageUrl", "cover_image_url", "_cover_image_url", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("thumbnailImageUrl", "thumbnail_image_url", "_thumbnail_image_url", str, None, PredefinedSerializer(), optional=True), +] + +UpdateSandboxSubmissionNameRequest._fields = [ + FieldMetadata("submissionId", "submission_id", "_submission_id", int, 0, PredefinedSerializer()), + FieldMetadata("name", "name", "_name", str, "", PredefinedSerializer()), +] + +UpdateTeamsVisibilityRequest._fields = [ + FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()), + FieldMetadata("teamIds", "team_ids", "_team_ids", int, [], ListSerializer(PredefinedSerializer())), + FieldMetadata("hide", "hide", "_hide", bool, False, PredefinedSerializer()), +] +