diff --git a/kagglesdk/__init__.py b/kagglesdk/__init__.py index 668c16a..0da479b 100644 --- a/kagglesdk/__init__.py +++ b/kagglesdk/__init__.py @@ -1,4 +1,4 @@ -__version__ = "0.1.32" +__version__ = "0.1.33" from kagglesdk.kaggle_client import KaggleClient from kagglesdk.kaggle_creds import KaggleCredentials diff --git a/kagglesdk/benchmarks/types/benchmark_enums.py b/kagglesdk/benchmarks/types/benchmark_enums.py index 2582c83..c12d916 100644 --- a/kagglesdk/benchmarks/types/benchmark_enums.py +++ b/kagglesdk/benchmarks/types/benchmark_enums.py @@ -38,8 +38,9 @@ class BenchmarkTaskVersionSource(enum.Enum): """Created by the LIH 'Benchmark Sandbox: Discover What Works' flow.""" WEB = 2 r""" - Created via the kaggle.com web client (e.g. CreateBenchmarkTaskFromPrompt - or saving a benchmark task from a kernel session). + Created via a kaggle.com web RPC (e.g. CreateBenchmarkTaskFromPrompt, + CreateBenchmarkTaskFromDockerImage, or saving a benchmark task from a + kernel session). """ CLI = 3 """Created via the Kaggle CLI / public BenchmarkTasksApi handler.""" diff --git a/kagglesdk/benchmarks/types/benchmark_task_run_service.py b/kagglesdk/benchmarks/types/benchmark_task_run_service.py index 09c28dc..652cb94 100644 --- a/kagglesdk/benchmarks/types/benchmark_task_run_service.py +++ b/kagglesdk/benchmarks/types/benchmark_task_run_service.py @@ -16,6 +16,10 @@ class BatchScheduleBenchmarkModelVersionResult(KaggleObject): benchmark_task_version_id (int) One of the values provided in BatchScheduleBenchmarkTaskRunsRequest.benchmark_task_versions + parent_task_version_id (int) + When the requested benchmark_task_version_id is a child of another task + version, scheduling is redirected to the parent and this field reports the + parent's id. Unset when the requested task version was executed directly. """ def __init__(self): @@ -23,6 +27,7 @@ def __init__(self): self._run_scheduled = False self._run_skipped_reason = None self._benchmark_task_version_id = 0 + self._parent_task_version_id = None self._freeze() @property @@ -93,11 +98,30 @@ def run_skipped_reason(self, run_skipped_reason: Optional[str]): raise TypeError('run_skipped_reason must be of type str') self._run_skipped_reason = run_skipped_reason + @property + def parent_task_version_id(self) -> int: + r""" + When the requested benchmark_task_version_id is a child of another task + version, scheduling is redirected to the parent and this field reports the + parent's id. Unset when the requested task version was executed directly. + """ + return self._parent_task_version_id or 0 + + @parent_task_version_id.setter + def parent_task_version_id(self, parent_task_version_id: Optional[int]): + if parent_task_version_id is None: + del self.parent_task_version_id + return + if not isinstance(parent_task_version_id, int): + raise TypeError('parent_task_version_id must be of type int') + self._parent_task_version_id = parent_task_version_id + BatchScheduleBenchmarkModelVersionResult._fields = [ FieldMetadata("benchmarkModelVersionId", "benchmark_model_version_id", "_benchmark_model_version_id", int, 0, PredefinedSerializer()), FieldMetadata("runScheduled", "run_scheduled", "_run_scheduled", bool, False, PredefinedSerializer()), FieldMetadata("runSkippedReason", "run_skipped_reason", "_run_skipped_reason", str, None, PredefinedSerializer(), optional=True), FieldMetadata("benchmarkTaskVersionId", "benchmark_task_version_id", "_benchmark_task_version_id", int, 0, PredefinedSerializer()), + FieldMetadata("parentTaskVersionId", "parent_task_version_id", "_parent_task_version_id", int, None, PredefinedSerializer(), optional=True), ] diff --git a/kagglesdk/benchmarks/types/benchmark_task_service.py b/kagglesdk/benchmarks/types/benchmark_task_service.py new file mode 100644 index 0000000..dd81074 --- /dev/null +++ b/kagglesdk/benchmarks/types/benchmark_task_service.py @@ -0,0 +1,138 @@ +from kagglesdk.kaggle_object import * + +class EnvVariable(KaggleObject): + r""" + Environment variable on a DOCKER_IMAGE BenchmarkTask's container. + + - `key`: variable name (e.g. `API_BASE_URL`). + - `value`: literal value, OR (when `is_secret_name` is true) the name + of a UserSecret on the caller's account. + - `is_secret_name`: when true, the system resolves `value` against the + caller's UserSecrets at runtime and injects the resolved secret. + + Attributes: + key (str) + value (str) + is_secret_name (bool) + """ + + def __init__(self): + self._key = "" + self._value = "" + self._is_secret_name = False + self._freeze() + + @property + def key(self) -> str: + return self._key + + @key.setter + def key(self, key: str): + if key is None: + del self.key + return + if not isinstance(key, str): + raise TypeError('key must be of type str') + self._key = key + + @property + def value(self) -> str: + return self._value + + @value.setter + def value(self, value: str): + if value is None: + del self.value + return + if not isinstance(value, str): + raise TypeError('value must be of type str') + self._value = value + + @property + def is_secret_name(self) -> bool: + return self._is_secret_name + + @is_secret_name.setter + def is_secret_name(self, is_secret_name: bool): + if is_secret_name is None: + del self.is_secret_name + return + if not isinstance(is_secret_name, bool): + raise TypeError('is_secret_name must be of type bool') + self._is_secret_name = is_secret_name + + +class UserSecret(KaggleObject): + r""" + UserSecret to create/update on the caller's account before running a + DOCKER_IMAGE BenchmarkTask. + + - `name`: secret label (matched against existing UserSecrets by Label). + - `value`: plaintext secret value. + - `override_existing`: when true, replace any existing secret with the + same name. When false, fail with AlreadyExists on a name collision. + + Attributes: + name (str) + value (str) + override_existing (bool) + """ + + def __init__(self): + self._name = "" + self._value = "" + self._override_existing = False + self._freeze() + + @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 + + @property + def value(self) -> str: + return self._value + + @value.setter + def value(self, value: str): + if value is None: + del self.value + return + if not isinstance(value, str): + raise TypeError('value must be of type str') + self._value = value + + @property + def override_existing(self) -> bool: + return self._override_existing + + @override_existing.setter + def override_existing(self, override_existing: bool): + if override_existing is None: + del self.override_existing + return + if not isinstance(override_existing, bool): + raise TypeError('override_existing must be of type bool') + self._override_existing = override_existing + + +EnvVariable._fields = [ + FieldMetadata("key", "key", "_key", str, "", PredefinedSerializer()), + FieldMetadata("value", "value", "_value", str, "", PredefinedSerializer()), + FieldMetadata("isSecretName", "is_secret_name", "_is_secret_name", bool, False, PredefinedSerializer()), +] + +UserSecret._fields = [ + FieldMetadata("name", "name", "_name", str, "", PredefinedSerializer()), + FieldMetadata("value", "value", "_value", str, "", PredefinedSerializer()), + FieldMetadata("overrideExisting", "override_existing", "_override_existing", bool, False, PredefinedSerializer()), +] + diff --git a/kagglesdk/benchmarks/types/benchmark_tasks_api_service.py b/kagglesdk/benchmarks/types/benchmark_tasks_api_service.py index 886dd01..8d41088 100644 --- a/kagglesdk/benchmarks/types/benchmark_tasks_api_service.py +++ b/kagglesdk/benchmarks/types/benchmark_tasks_api_service.py @@ -1,6 +1,7 @@ from datetime import datetime from kagglesdk.benchmarks.types.benchmark_enums import BenchmarkTaskRunState, BenchmarkTaskVersionCreationState, BenchmarkTaskVersionSource from kagglesdk.benchmarks.types.benchmark_task_run_service import BatchScheduleBenchmarkModelVersionResult +from kagglesdk.benchmarks.types.benchmark_task_service import EnvVariable, UserSecret from kagglesdk.benchmarks.types.benchmark_types import BenchmarkTaskOptions from kagglesdk.kaggle_object import * from typing import List, Optional @@ -542,12 +543,17 @@ class ApiCreateBenchmarkTaskRequest(KaggleObject): all previously-attached sources for that version. Callers that want to preserve the previous version's options must echo them back on each push. + definition (BenchmarkTaskDefinition) + What backs this task (notebook / docker image / Harbor git repo) and + any per-type configuration. Pairs with the BenchmarkTaskDefinitionType + enum stored on the entity. """ def __init__(self): self._slug = "" self._text = "" self._options = None + self._definition = None self._freeze() @property @@ -607,6 +613,24 @@ def options(self, options: Optional[Optional['BenchmarkTaskOptions']]): raise TypeError('options must be of type BenchmarkTaskOptions') self._options = options + @property + def definition(self) -> Optional['BenchmarkTaskDefinition']: + r""" + What backs this task (notebook / docker image / Harbor git repo) and + any per-type configuration. Pairs with the BenchmarkTaskDefinitionType + enum stored on the entity. + """ + return self._definition or None + + @definition.setter + def definition(self, definition: Optional[Optional['BenchmarkTaskDefinition']]): + if definition is None: + del self.definition + return + if not isinstance(definition, BenchmarkTaskDefinition): + raise TypeError('definition must be of type BenchmarkTaskDefinition') + self._definition = definition + def endpoint(self): path = '/api/v1/benchmarks/tasks/push' return path.format_map(self.to_field_map(self)) @@ -1183,6 +1207,182 @@ def body_fields(): return '*' +class BenchmarkTaskDefinition(KaggleObject): + r""" + Attributes: + notebook (BenchmarkTaskNotebookDefinition) + docker_image (BenchmarkTaskDockerImageDefinition) + harbor_git (BenchmarkTaskGitDefinition) + """ + + def __init__(self): + self._notebook = None + self._docker_image = None + self._harbor_git = None + self._freeze() + + @property + def notebook(self) -> Optional['BenchmarkTaskNotebookDefinition']: + return self._notebook or None + + @notebook.setter + def notebook(self, notebook: Optional['BenchmarkTaskNotebookDefinition']): + if notebook is None: + del self.notebook + return + if not isinstance(notebook, BenchmarkTaskNotebookDefinition): + raise TypeError('notebook must be of type BenchmarkTaskNotebookDefinition') + del self.docker_image + del self.harbor_git + self._notebook = notebook + + @property + def docker_image(self) -> Optional['BenchmarkTaskDockerImageDefinition']: + return self._docker_image or None + + @docker_image.setter + def docker_image(self, docker_image: Optional['BenchmarkTaskDockerImageDefinition']): + if docker_image is None: + del self.docker_image + return + if not isinstance(docker_image, BenchmarkTaskDockerImageDefinition): + raise TypeError('docker_image must be of type BenchmarkTaskDockerImageDefinition') + del self.notebook + del self.harbor_git + self._docker_image = docker_image + + @property + def harbor_git(self) -> Optional['BenchmarkTaskGitDefinition']: + return self._harbor_git or None + + @harbor_git.setter + def harbor_git(self, harbor_git: Optional['BenchmarkTaskGitDefinition']): + if harbor_git is None: + del self.harbor_git + return + if not isinstance(harbor_git, BenchmarkTaskGitDefinition): + raise TypeError('harbor_git must be of type BenchmarkTaskGitDefinition') + del self.notebook + del self.docker_image + self._harbor_git = harbor_git + + +class BenchmarkTaskDockerImageDefinition(KaggleObject): + r""" + TODO(bml): Setup for docker images + + """ + + pass + +class BenchmarkTaskGitDefinition(KaggleObject): + r""" + Harbor task definition in a GitHub repo subpath (at a specific commit SHA). + + Attributes: + url (str) + HTTPS URL of the GitHub repo containing the Harbor task. + commit_hash (str) + Specific commit SHA for the repository to pin against. + subpath (str) + Subpath to the task within the repo. + env_variables (EnvVariable) + Optional. Environment variables to expose to the Harbor session container. + secrets (UserSecret) + Optional. Create/update UserSecrets inline before running. + """ + + def __init__(self): + self._url = "" + self._commit_hash = "" + self._subpath = "" + self._env_variables = [] + self._secrets = [] + self._freeze() + + @property + def url(self) -> str: + """HTTPS URL of the GitHub repo containing the Harbor task.""" + 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 + + @property + def commit_hash(self) -> str: + """Specific commit SHA for the repository to pin against.""" + return self._commit_hash + + @commit_hash.setter + def commit_hash(self, commit_hash: str): + if commit_hash is None: + del self.commit_hash + return + if not isinstance(commit_hash, str): + raise TypeError('commit_hash must be of type str') + self._commit_hash = commit_hash + + @property + def subpath(self) -> str: + """Subpath to the task within the repo.""" + return self._subpath + + @subpath.setter + def subpath(self, subpath: str): + if subpath is None: + del self.subpath + return + if not isinstance(subpath, str): + raise TypeError('subpath must be of type str') + self._subpath = subpath + + @property + def env_variables(self) -> Optional[List[Optional['EnvVariable']]]: + """Optional. Environment variables to expose to the Harbor session container.""" + return self._env_variables + + @env_variables.setter + def env_variables(self, env_variables: Optional[List[Optional['EnvVariable']]]): + if env_variables is None: + del self.env_variables + return + if not isinstance(env_variables, list): + raise TypeError('env_variables must be of type list') + if not all([isinstance(t, EnvVariable) for t in env_variables]): + raise TypeError('env_variables must contain only items of type EnvVariable') + self._env_variables = env_variables + + @property + def secrets(self) -> Optional[List[Optional['UserSecret']]]: + """Optional. Create/update UserSecrets inline before running.""" + return self._secrets + + @secrets.setter + def secrets(self, secrets: Optional[List[Optional['UserSecret']]]): + if secrets is None: + del self.secrets + return + if not isinstance(secrets, list): + raise TypeError('secrets must be of type list') + if not all([isinstance(t, UserSecret) for t in secrets]): + raise TypeError('secrets must contain only items of type UserSecret') + self._secrets = secrets + + +class BenchmarkTaskNotebookDefinition(KaggleObject): + r""" + TODO(bml): Get parity with text + options fields in the create request proto + + """ + + pass + ApiBatchScheduleBenchmarkTaskRunsRequest._fields = [ FieldMetadata("taskSlugs", "task_slugs", "_task_slugs", ApiBenchmarkTaskSlug, [], ListSerializer(KaggleObjectSerializer())), FieldMetadata("modelVersionSlugs", "model_version_slugs", "_model_version_slugs", str, [], ListSerializer(PredefinedSerializer())), @@ -1226,6 +1426,7 @@ def body_fields(): FieldMetadata("slug", "slug", "_slug", str, "", PredefinedSerializer()), FieldMetadata("text", "text", "_text", str, "", PredefinedSerializer()), FieldMetadata("options", "options", "_options", BenchmarkTaskOptions, None, KaggleObjectSerializer(), optional=True), + FieldMetadata("definition", "definition", "_definition", BenchmarkTaskDefinition, None, KaggleObjectSerializer(), optional=True), ] ApiDownloadBenchmarkTaskRunOutputRequest._fields = [ @@ -1281,3 +1482,21 @@ def body_fields(): FieldMetadata("publishBackingNotebook", "publish_backing_notebook", "_publish_backing_notebook", bool, False, PredefinedSerializer()), ] +BenchmarkTaskDefinition._fields = [ + FieldMetadata("notebook", "notebook", "_notebook", BenchmarkTaskNotebookDefinition, None, KaggleObjectSerializer(), optional=True), + FieldMetadata("dockerImage", "docker_image", "_docker_image", BenchmarkTaskDockerImageDefinition, None, KaggleObjectSerializer(), optional=True), + FieldMetadata("harborGit", "harbor_git", "_harbor_git", BenchmarkTaskGitDefinition, None, KaggleObjectSerializer(), optional=True), +] + +BenchmarkTaskDockerImageDefinition._fields = [] + +BenchmarkTaskGitDefinition._fields = [ + FieldMetadata("url", "url", "_url", str, "", PredefinedSerializer()), + FieldMetadata("commitHash", "commit_hash", "_commit_hash", str, "", PredefinedSerializer()), + FieldMetadata("subpath", "subpath", "_subpath", str, "", PredefinedSerializer()), + FieldMetadata("envVariables", "env_variables", "_env_variables", EnvVariable, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("secrets", "secrets", "_secrets", UserSecret, [], ListSerializer(KaggleObjectSerializer())), +] + +BenchmarkTaskNotebookDefinition._fields = [] + diff --git a/kagglesdk/competitions/services/competition_api_service.py b/kagglesdk/competitions/services/competition_api_service.py index b235caf..9f635c2 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, ApiCompetitionPage, ApiCreateCodeSubmissionRequest, ApiCreateCodeSubmissionResponse, ApiCreateCompetitionDataRequest, ApiCreateCompetitionDataResponse, ApiCreateCompetitionPageRequest, ApiCreateCompetitionRequest, ApiCreateCompetitionResponse, ApiCreateSubmissionRequest, ApiCreateSubmissionResponse, ApiDeleteCompetitionPageRequest, 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, ApiUpdateCompetitionPageRequest, ApiUpdateCompetitionSettingsRequest +from kagglesdk.competitions.types.competition_api_service import ApiCompetition, ApiCompetitionPage, ApiCreateCodeSubmissionRequest, ApiCreateCodeSubmissionResponse, ApiCreateCompetitionDataRequest, ApiCreateCompetitionDataResponse, ApiCreateCompetitionPageRequest, ApiCreateCompetitionRequest, ApiCreateCompetitionResponse, ApiCreateCompetitionSolutionRequest, ApiCreateSubmissionRequest, ApiCreateSubmissionResponse, ApiDeleteCompetitionPageRequest, 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, ApiUpdateCompetitionPageRequest, ApiUpdateCompetitionSettingsRequest from kagglesdk.competitions.types.host_service import CompetitionSettings from kagglesdk.datasets.databundles.types.databundle_api_types import ApiDirectoryContent, ApiFilesSummary from kagglesdk.kaggle_http_client import KaggleHttpClient @@ -326,6 +326,22 @@ def create_competition_data(self, request: ApiCreateCompetitionDataRequest = Non return self._client.call("competitions.CompetitionApiService", "CreateCompetitionData", request, ApiCreateCompetitionDataResponse) + def create_competition_solution(self, request: ApiCreateCompetitionSolutionRequest = None): + r""" + Not MCP-exported: the prerequisite blob upload step (start_blob_upload + + signed-URL PUT) has no MCP equivalent, so the tool would be unusable from + MCP clients today. Public REST + Python SDK only; the kaggle CLI drives it. + + Args: + request (ApiCreateCompetitionSolutionRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiCreateCompetitionSolutionRequest() + + self._client.call("competitions.CompetitionApiService", "CreateCompetitionSolution", 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 deleted file mode 100644 index a99896e..0000000 --- a/kagglesdk/competitions/services/episode_service.py +++ /dev/null @@ -1,169 +0,0 @@ -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 deleted file mode 100644 index d7d5327..0000000 --- a/kagglesdk/competitions/services/host_service.py +++ /dev/null @@ -1,398 +0,0 @@ -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 e891ce0..787a0d3 100644 --- a/kagglesdk/competitions/types/competition.py +++ b/kagglesdk/competitions/types/competition.py @@ -2,6 +2,22 @@ from kagglesdk.kaggle_object import * from typing import Optional +class PubliclyCloneable(enum.Enum): + PUBLICLY_CLONEABLE_UNSPECIFIED = 0 + """not cloneable""" + PUBLICLY_CLONEABLE_WITH_PRIVATE_SOLUTION_FILE = 1 + r""" + publicly cloneable - cloning this competition will NOT give you access to + solution file + """ + PUBLICLY_CLONEABLE_WITH_PUBLIC_SOLUTION_FILE = 2 + r""" + publicly cloneable - cloning this competition will give you access to the + solution file + """ + PUBLICLY_CLONEABLE_ENABLE_HACKATHON_CLONING = 3 + """enables non-admin non-host users to clone a closed hackathon competition""" + class RewardTypeId(enum.Enum): REWARD_TYPE_ID_UNSPECIFIED = 0 USD = 1 diff --git a/kagglesdk/competitions/types/competition_api_service.py b/kagglesdk/competitions/types/competition_api_service.py index cf12988..0d4c193 100644 --- a/kagglesdk/competitions/types/competition_api_service.py +++ b/kagglesdk/competitions/types/competition_api_service.py @@ -1565,6 +1565,64 @@ def url(self, url: str): self._url = url +class ApiCreateCompetitionSolutionRequest(KaggleObject): + r""" + Attributes: + competition_name (str) + blob_token (str) + Blob token returned by /api/v1/blobs/upload after the matching upload PUT. + The blob must be a single CSV in the same shape as a submission file. + """ + + def __init__(self): + self._competition_name = "" + self._blob_token = "" + 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 blob_token(self) -> str: + r""" + Blob token returned by /api/v1/blobs/upload after the matching upload PUT. + The blob must be a single CSV in the same shape as a submission file. + """ + 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 + + def endpoint(self): + path = '/api/v1/competitions/{competition_name}/solution' + return path.format_map(self.to_field_map(self)) + + + @staticmethod + def method(): + return 'POST' + + @staticmethod + def body_fields(): + return '*' + + class ApiCreateSubmissionRequest(KaggleObject): r""" Attributes: @@ -4430,6 +4488,11 @@ def body_fields(): FieldMetadata("url", "url", "_url", str, "", PredefinedSerializer()), ] +ApiCreateCompetitionSolutionRequest._fields = [ + FieldMetadata("competitionName", "competition_name", "_competition_name", str, "", PredefinedSerializer()), + FieldMetadata("blobToken", "blob_token", "_blob_token", str, "", PredefinedSerializer()), +] + ApiCreateSubmissionRequest._fields = [ FieldMetadata("competitionName", "competition_name", "_competition_name", str, "", PredefinedSerializer()), FieldMetadata("blobFileTokens", "blob_file_tokens", "_blob_file_tokens", str, "", PredefinedSerializer()), diff --git a/kagglesdk/competitions/types/episode_service.py b/kagglesdk/competitions/types/episode_service.py deleted file mode 100644 index 76d87e1..0000000 --- a/kagglesdk/competitions/types/episode_service.py +++ /dev/null @@ -1,1475 +0,0 @@ -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 index c40af10..45b3071 100644 --- a/kagglesdk/competitions/types/host_service.py +++ b/kagglesdk/competitions/types/host_service.py @@ -1,230 +1,8 @@ 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.competitions.types.competition import PubliclyCloneable +from kagglesdk.competitions.types.competition_enums import HostSegment 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 - +from typing import Optional class CompetitionSettings(KaggleObject): r""" @@ -745,1532 +523,6 @@ def rerun_override_kernel_id(self, rerun_override_kernel_id: Optional[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()), @@ -2300,186 +552,3 @@ def hide(self, hide: bool): 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()), -] - diff --git a/kagglesdk/kaggle_http_client.py b/kagglesdk/kaggle_http_client.py index 8ede93b..da33bfe 100644 --- a/kagglesdk/kaggle_http_client.py +++ b/kagglesdk/kaggle_http_client.py @@ -42,14 +42,10 @@ def _get_apikey_creds(): if not kaggle_json or not kaggle_json.strip(): return None - try: - # Be careful, since the file may be used for more than credential storage. - api_key_data = json.loads(kaggle_json) - username = api_key_data["username"] - api_key = api_key_data["key"] - return username, api_key - except KeyError: - return None + api_key_data = json.loads(kaggle_json) + username = api_key_data["username"] + api_key = api_key_data["key"] + return username, api_key class KaggleHttpClient(object): @@ -59,14 +55,14 @@ class KaggleHttpClient(object): _xsrf_header_name = "X-XSRF-TOKEN" def __init__( - self, - env: KaggleEnv = None, - verbose: bool = False, - username: str = None, - password: str = None, - api_token: str = None, - user_agent: str = "kaggle-api/v1.7.0", # Was: V2 - response_processor=None, + self, + env: KaggleEnv = None, + verbose: bool = False, + username: str = None, + password: str = None, + api_token: str = None, + user_agent: str = "kaggle-api/v1.7.0", # Was: V2 + response_processor=None, ): self._env = env or get_env() self._signed_in = None @@ -80,25 +76,21 @@ def __init__( self._response_processor = response_processor def call( - self, - service_name: str, - request_name: str, - request: KaggleObject, - response_type: Type[KaggleObject], + self, + service_name: str, + request_name: str, + request: KaggleObject, + response_type: Type[KaggleObject], ): self._init_session() http_request = self._prepare_request(service_name, request_name, request) # Merge environment settings into session - settings = self._session.merge_environment_settings( - http_request.url, {}, None, None, None - ) + settings = self._session.merge_environment_settings(http_request.url, {}, None, None, None) # Use stream=True for file downloads to avoid loading entire file into memory # See: https://github.com/Kaggle/kaggle-api/issues/754 - if response_type is not None and ( - response_type == FileDownload or response_type == HttpRedirect - ): + if response_type is not None and (response_type == FileDownload or response_type == HttpRedirect): settings["stream"] = True http_response = self._session.send(http_request, **settings) @@ -106,9 +98,7 @@ def call( response = self._prepare_response(response_type, http_response) return response - def _prepare_request( - self, service_name: str, request_name: str, request: KaggleObject - ): + def _prepare_request(self, service_name: str, request_name: str, request: KaggleObject): request_url = self._get_request_url(service_name, request_name) http_request = requests.Request( method="POST", @@ -128,9 +118,7 @@ def _prepare_response(self, response_type, http_response): if "application/json" in http_response.headers["Content-Type"]: resp = http_response.json() if "code" in resp and resp["code"] >= 400: - raise requests.exceptions.HTTPError( - resp["message"], response=http_response - ) + raise requests.exceptions.HTTPError(resp["message"], response=http_response) except KeyError: pass http_response.raise_for_status() @@ -145,9 +133,7 @@ def _print_request(self, request): if not self._verbose: return self._print("---------------------Request----------------------") - self._print( - f"{request.method} {request.url}\n{_headers_to_str(request.headers)}\n\n{request.body}" - ) + self._print(f"{request.method} {request.url}\n{_headers_to_str(request.headers)}\n\n{request.body}") self._print("--------------------------------------------------") def _print_response(self, response, body=True): @@ -176,9 +162,7 @@ def _init_session(self): return self._session self._session = requests.Session() - self._session.headers.update( - {"User-Agent": self._user_agent, "Content-Type": "application/json"} - ) + self._session.headers.update({"User-Agent": self._user_agent, "Content-Type": "application/json"}) iap_token = self._get_iap_token_if_required() if iap_token is not None: @@ -219,19 +203,17 @@ def _fill_xsrf_token(self, iap_token): self._session.headers.update( { - KaggleHttpClient._xsrf_header_name: self._session.cookies[ - KaggleHttpClient._xsrf_cookie_name - ], + KaggleHttpClient._xsrf_header_name: self._session.cookies[KaggleHttpClient._xsrf_cookie_name], } ) def build_start_oauth_url( - self, - client_id: str, - redirect_uri: str, - scope: list[str], - state: str, - code_challenge: str, + self, + client_id: str, + redirect_uri: str, + scope: list[str], + state: str, + code_challenge: str, ) -> str: params = { "response_type": "code", @@ -252,9 +234,7 @@ def get_oauth_default_redirect_url(self) -> str: return f"{self.get_non_api_endpoint()}/account/api/oauth/token" def get_non_api_endpoint(self) -> str: - return ( - "https://www.kaggle.com" if self._env == KaggleEnv.PROD else self._endpoint - ) + return "https://www.kaggle.com" if self._env == KaggleEnv.PROD else self._endpoint class BearerAuth(requests.auth.AuthBase): @@ -270,7 +250,7 @@ def _try_fill_auth(self): return if self._api_token is None: - api_token, _ = get_access_token_from_env() + (api_token, _) = get_access_token_from_env() self._api_token = api_token if self._api_token is not None: @@ -292,7 +272,5 @@ def _try_fill_auth(self): def _get_request_url(self, service_name: str, request_name: str): # On prod, API endpoints are served under https://api.kaggle.com/v1, # but on staging/admin/local, they are served under http://localhost/api/v1. - base_url = ( - self._endpoint if self._env == KaggleEnv.PROD else f"{self._endpoint}/api" - ) + base_url = self._endpoint if self._env == KaggleEnv.PROD else f"{self._endpoint}/api" return f"{base_url}/v1/{service_name}/{request_name}" diff --git a/kagglesdk/kernels/types/kernels_api_service.py b/kagglesdk/kernels/types/kernels_api_service.py index b01a8ec..1ca8324 100644 --- a/kagglesdk/kernels/types/kernels_api_service.py +++ b/kagglesdk/kernels/types/kernels_api_service.py @@ -779,7 +779,7 @@ def wait_for_logs_url_seconds(self, wait_for_logs_url_seconds: Optional[int]): self._wait_for_logs_url_seconds = wait_for_logs_url_seconds def endpoint(self): - path = '/api/v1/kernels/sessions/{kernel_session_id}/logs/stream' + path = 'Custom endpoint required' return path.format_map(self.to_field_map(self)) @staticmethod diff --git a/kagglesdk/security/types/security_types.py b/kagglesdk/security/types/security_types.py index a883b5c..e82a51b 100644 --- a/kagglesdk/security/types/security_types.py +++ b/kagglesdk/security/types/security_types.py @@ -99,6 +99,7 @@ class KaggleResourceType(enum.Enum): KAGGLE_RESOURCE_TYPE_BENCHMARK_TASKS = 710 KAGGLE_RESOURCE_TYPE_BENCHMARK_TASK_VERSIONS = 712 KAGGLE_RESOURCE_TYPE_BENCHMARK_TASK_RUNS = 714 + KAGGLE_RESOURCE_TYPE_KKB_SESSIONS = 716 KAGGLE_RESOURCE_TYPE_COURSE_TRACKS = 800 """---------- Courses ----------""" KAGGLE_RESOURCE_TYPE_COURSE_LESSONS = 802